Merge remote-tracking branch 'origin/develop' into 4504-p3-glide-bug-npx-poly-prepare-does-not-find-any-deployables-in-windows

Author: Daniel-Estoll

index.d.ts

@@ -6,12 +6,19 @@ type Visibility = 'PUBLIC' | 'TENANT' | 'ENVIRONMENT';
 type PolyDeployable<CustomConfig extends Record<string, any> = {}> = {
   context: string;
   name: string;
+  description?: string;
   disableAi?: boolean; // Disable use of AI for filling in missing descriptions
 } & CustomConfig;
 
-type PolyFunction = PolyDeployable<{ logsEnabled?: boolean; visibility?: Visibility }>;
+type PolyFunction = PolyDeployable<{ visibility?: Visibility }>;
 
-export type PolyServerFunction = PolyFunction & { alwaysOn?: boolean };
+export type PolyServerFunction = PolyFunction & { 
+  alwaysOn?: boolean;
+  logsEnabled?: boolean;
+  serverSideAsync?: boolean;
+  cachePolyLibrary?: boolean;
+  generateContexts?: string[];
+};
 
 export type PolyClientFunction = PolyFunction;
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "polyapi",
-  "version": "0.23.26",
+  "version": "0.24.3",
   "description": "Poly is a CLI tool to help create and manage your Poly definitions.",
   "license": "MIT",
   "repository": {
@@ -28,6 +28,7 @@
     "prepublishOnly": "npm run lint && npm run build",
     "preversion": "npm run lint",
     "postversion": "git push && git push --tags",
+
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "devDependencies": {

package.json

@@ -8,12 +8,47 @@ import { loadConfig } from './config';
 import { type RenameT } from './commands/model';
 import { DEFAULT_POLY_PATH } from './constants';
 import { isValidHttpUrl } from './utils';
+import fs from 'fs';
+import path from 'path';
 
 if (process.env.NO_COLOR) {
   // Support NO_COLOR env variable https://no-color.org/
   chalk.level = 0;
 }
 
+const showWelcomeIfFirstTime = () => {
+  try {
+    const polyDir = DEFAULT_POLY_PATH;
+    const welcomeFile = path.join(polyDir, '.welcome-shown');
+    
+    // If welcome has already been shown, return early
+    if (fs.existsSync(welcomeFile)) {
+      return;
+    }
+    
+    // Get version from package.json
+    const packagePath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const version = packageJson.version;
+    
+    // Show welcome message
+    console.log('');
+    console.log(chalk.green('✓ PolyAPI SDK installed successfully!'));
+    console.log(chalk.blue(`📦 Version: ${version}`));
+    console.log('');
+    console.log(chalk.yellow('Getting started:'));
+    console.log('  • Run ' + chalk.cyan('poly --help') + ' to see all available commands');
+    console.log('  • Run ' + chalk.cyan('poly setup') + ' to configure your Poly connection');
+    console.log('');
+    
+    // Ensure .poly directory exists and mark welcome as shown
+    fs.mkdirSync(polyDir, { recursive: true });
+    fs.writeFileSync(welcomeFile, new Date().toISOString());
+  } catch (error) {
+    // Silently fail if there's an issue - don't break the CLI
+  }
+};
+
 const checkPolyConfig = (polyPath: string) => {
   loadConfig(polyPath);
 
@@ -24,6 +59,9 @@ const checkPolyConfig = (polyPath: string) => {
   return true;
 };
 
+// Show welcome message on first usage
+showWelcomeIfFirstTime();
+
 void yargs
   .usage('$0 <cmd> [args]')
   .command(
@@ -236,6 +274,10 @@ void yargs
           .option('execution-api-key', {
             describe: 'Optional API key for server functions',
             type: 'string',
+          })
+          .option('cache-poly-library', {
+            describe: 'Server function only - cache the poly library to improve function performance',
+            type: 'boolean',
           }),
       async ({
         name,
@@ -247,6 +289,7 @@ void yargs
         logs,
         generateContexts,
         executionApiKey,
+        cachePolyLibrary,
       }) => {
         const logsEnabled =
           logs === 'enabled' ? true : logs === 'disabled' ? false : undefined;
@@ -266,6 +309,8 @@ void yargs
                           ? 'Invalid value for `logs` option.'
                           : executionApiKey && !uuidValidate(executionApiKey)
                             ? 'Invalid value for `execution-api-key`. Must be a valid PolyAPI Key.'
+                            : cachePolyLibrary && !server
+                              ? 'Option `cache-poly-library` is only for server functions (--server).'
                             : '';
         if (err) {
           shell.echo(chalk.redBright('ERROR:'), err);
@@ -286,6 +331,7 @@ void yargs
           logsEnabled,
           generateContexts,
           executionApiKey,
+          cachePolyLibrary,
         );
       },
     );

src/cli.ts

@@ -1,4 +1,3 @@
- 
 import fs from 'fs';
 import chalk from 'chalk';
 import shell from 'shelljs';
@@ -31,6 +30,7 @@ export const addOrUpdateCustomFunction = async (
   logsEnabled: boolean | undefined,
   generateContexts: string | undefined,
   executionApiKey: string | null | undefined,
+  cachePolyLibrary: boolean | undefined,
 ) => {
   loadConfig(polyPath);
 
@@ -96,6 +96,7 @@ export const addOrUpdateCustomFunction = async (
       const other: Record<string, any> = {};
       if (generateContexts) { other.generateContexts = generateContexts.split(','); }
       if (logsEnabled !== undefined) other.logsEnabled = logsEnabled;
+      if (cachePolyLibrary !== undefined) other.cachePolyLibrary = cachePolyLibrary;
 
       customFunction = await createOrUpdateServerFunction(
         context,

src/commands/function.ts

@@ -11,6 +11,7 @@ import {
   ServerFunctionSpecification,
   ServerVariableSpecification,
   Specification,
+  TableSpecification,
   WebhookHandleSpecification,
 } from '../../types';
 import { getSpecs } from '../../api';
@@ -37,6 +38,7 @@ import {
   setGenerationErrors,
 } from './types';
 import { generateSchemaTSDeclarationFiles } from './schemaTypes';
+import { generateTableTSDeclarationFiles } from './table';
 
 // Register the eq helper for equality comparison
 handlebars.registerHelper('eq', (a, b) => a === b);
@@ -62,6 +64,7 @@ const prepareDir = async (polyPath: string) => {
   fs.mkdirSync(`${libPath}/webhooks`);
   fs.mkdirSync(`${libPath}/server`);
   fs.mkdirSync(`${libPath}/vari`);
+  fs.mkdirSync(`${libPath}/tabi`);
   fs.mkdirSync(`${libPath}/schemas`);
 
   if (polyPath !== DEFAULT_POLY_PATH) {
@@ -138,6 +141,9 @@ const generateJSFiles = async (
   const serverVariables = specs.filter(
     (spec) => spec.type === 'serverVariable',
   ) as ServerVariableSpecification[];
+  const tables = specs.filter(
+    (spec) => spec.type === 'table',
+  ) as TableSpecification[];
 
   await generateIndexJSFile(libPath);
   await generatePolyCustomJSFile(libPath);
@@ -164,6 +170,10 @@ const generateJSFiles = async (
     generateServerVariableJSFiles(libPath, serverVariables),
     'variables',
   );
+  await tryAsync(
+    generateTableJSFiles(libPath, tables),
+    'tables',
+  );
 
   return customFnCodeGenerationErrors;
 };
@@ -323,6 +333,18 @@ const generateServerVariableJSFiles = async (
   );
 };
 
+const generateTableJSFiles = async (
+  libPath: string,
+  specifications: TableSpecification[],
+) => {
+  const tablesJSTemplate = handlebars.compile(loadTemplate('tabi/tables.js.hbs'));
+  fs.writeFileSync(
+    `${libPath}/tabi/tables.js`,
+    tablesJSTemplate({ specifications }),
+  );
+  fs.copyFileSync(templateUrl('tabi/index.js'), `${libPath}/tabi/index.js`);
+};
+
 const generateAuthFunctionJSFiles = async (
   libPath: string,
   specifications: AuthFunctionSpecification[],
@@ -607,6 +629,13 @@ export const generateSpecs = async (
         ),
         'schemas',
       );
+      await tryAsync(
+        generateTableTSDeclarationFiles(
+          libPath,
+          filteredSpecs.filter((s) => s.type === 'table') as TableSpecification[],
+        ),
+        'table types',
+      );
     }
 
     generateContextDataFile(libPath, filteredSpecs);

src/commands/generate/index.ts

@@ -56,13 +56,12 @@ export type JsonSchema = {
   $id?: string;
   $ref?: string;
   $schema?: string;
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  'x-poly-ref'?: SchemaRef;
   deprecated?: boolean;
   nullable?: boolean;
   enum?: ConstValueT[];
   const?: ConstValueT;
   definitions?: Record<string, JsonSchema>;
+  'x-poly-ref'?: SchemaRef;
   [k: string]: unknown;
 };
 
@@ -72,7 +71,7 @@ export type SchemaSpec = Omit<SchemaSpecification, 'definition'> & {
 
 type SchemaTree = Record<string, SchemaSpec | Record<string, SchemaSpec>>;
 
-const ws = memoize((depth = 1) =>
+export const ws = memoize((depth = 1) =>
   depth < 0 ? '' : new Array(depth).fill('  ').join(''),
 );
 const end = memoize((nested?: NestedT) =>
@@ -216,12 +215,13 @@ const printObjectSchema: PrintSchemaFn = (
     schema.description,
     depth,
     schema.deprecated,
-  )}${ws(depth)}${printTypeName(schema.title, key, nested, optional)}{`;
+  )}${ws(depth)}${printTypeName(schema.title, key, nested, optional)}`;
   if (
     schema.properties ||
     schema.patternProperties ||
     schema.additionalProperties
   ) {
+    result = `${result}{`;
     if (schema.properties) {
       Object.entries(schema.properties).forEach(([k, v]) => {
         result = `${result}${EOL}${printSchemaAsType(
@@ -265,8 +265,12 @@ const printObjectSchema: PrintSchemaFn = (
       }
     }
     result = `${result}${EOL}${ws(depth)}}${end(nested)}`;
+  } else if (nested) {
+    // Nested object type with no properties falls back to record type
+    result = `${result}Record<string, unknown>${end(nested)}`;
   } else {
-    result = `${result}}${end(nested)}`;
+    // Non-nested object type uses empty interface {}
+    result = `${result}{}${end(nested)}`;
   }
   return result;
 };
@@ -500,7 +504,7 @@ const printConstSchema: PrintSchemaFn = (
   }${end(nested)}`;
 };
 
-const printSchemaAsType: PrintSchemaFn = (
+export const printSchemaAsType: PrintSchemaFn = (
   schema: JsonSchema,
   key,
   depth = 0,