@slingr/cli 0.0.3 → 0.0.4

package/dist/scripts/generate-metadata.ts

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+/**
+ * Script to generate model and action metadata at runtime.
+ *
+ * This script is executed in the context of a user's Slingr application
+ * (copied to backend/ and run via ts-node). It loads models and actions,
+ * then uses Reflect.getMetadata() to extract field relationship info and
+ * action configuration.
+ *
+ * Output: frontend/generated/gql/metadata.ts
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// ============================================================================
+// Types (internal to this script)
+// ============================================================================
+
+interface FieldInfoData {
+  type: 'scalar' | 'reference' | 'composition' | 'sharedComposition' | 'owner' | 'file';
+  target?: string;
+  array?: boolean;
+}
+
+interface ModelInfoData {
+  fields: Record<string, FieldInfoData>;
+  persistent: boolean;
+  idType?: 'string' | 'int';
+}
+
+interface ActionInfoData {
+  operation: 'query' | 'mutation';
+  type: 'model' | 'global' | 'object';
+  paramsRef?: string;
+  returnsRef?: string;
+  returnsRefs?: string[];
+  modelRef?: string;
+  label?: string;
+  bulk?: boolean;
+  // Workflow-specific UI options
+  isWorkflow?: boolean;
+  blockingExecution?: boolean;
+  successMessage?: string;
+  errorMessage?: string;
+}
+
+// ============================================================================
+// Metadata extraction
+// ============================================================================
+
+function resolveTargetClass(proto: object, fieldName: string): Function | null {
+  const typeOptions = Reflect.getMetadata('field:type:options', proto, fieldName);
+  if (typeOptions?.elementType && typeof typeOptions.elementType === 'function') {
+    try {
+      const resolved = typeOptions.elementType();
+      if (typeof resolved === 'function') {
+        return resolved;
+      }
+    } catch {
+      /* fallback */
+    }
+  }
+
+  const designType = Reflect.getMetadata('design:type', proto, fieldName);
+  if (designType && designType !== Array && designType !== Object && typeof designType === 'function') {
+    return designType;
+  }
+
+  return null;
+}
+
+function detectIsArray(constructor: Function, proto: object, fieldName: string): boolean {
+  const isArrayMeta = Reflect.getMetadata('field:relationship:isArray', constructor, fieldName);
+  if (isArrayMeta === true) {
+    return true;
+  }
+
+  const arrayFields: string[] = Reflect.getMetadata('array:field:names', constructor) || [];
+  if (arrayFields.includes(fieldName)) {
+    return true;
+  }
+
+  const designType = Reflect.getMetadata('design:type', proto, fieldName);
+  return designType === Array;
+}
+
+function detectIdType(modelClass: new (...args: any[]) => any, fieldNames: string[]): 'string' | 'int' | undefined {
+  const proto = modelClass.prototype;
+
+  for (const fieldName of fieldNames) {
+    const isPrimaryKey = Reflect.getMetadata('field:primaryKey', proto, fieldName);
+    if (isPrimaryKey) {
+      const fieldType = Reflect.getMetadata('field:type', proto, fieldName);
+      if (fieldType === 'uuid' || fieldType === 'text' || fieldType === 'email') {
+        return 'string';
+      } else if (fieldType === 'integer') {
+        return 'int';
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function extractModelFields(
+  modelClass: new (...args: any[]) => any,
+  getAllFieldNamesFn: (constructor: Function) => string[]
+): Record<string, FieldInfoData> {
+  const fields: Record<string, FieldInfoData> = {};
+  const fieldNames = getAllFieldNamesFn(modelClass);
+  const proto = modelClass.prototype;
+
+  for (const fieldName of fieldNames) {
+    const relationshipType: string | undefined = Reflect.getMetadata('field:relationship:type', proto, fieldName);
+
+    if (!relationshipType) {
+      // Scalar field — check if array
+      const designType = Reflect.getMetadata('design:type', proto, fieldName);
+      const isArray = designType === Array;
+      fields[fieldName] = { type: 'scalar', ...(isArray && { array: true }) };
+    } else {
+      // Relationship field
+      const targetClass = resolveTargetClass(proto, fieldName);
+      const isArray = detectIsArray(modelClass, proto, fieldName);
+
+      // Check if target is AppFile or AppFile subclass
+      let fieldType: FieldInfoData['type'] = relationshipType as FieldInfoData['type'];
+      if (targetClass && relationshipType === 'reference') {
+        // Walk prototype chain to check if extends AppFile
+        let current = targetClass.prototype;
+        while (current) {
+          if (current.constructor.name === 'AppFile') {
+            fieldType = 'file';
+            break;
+          }
+          current = Object.getPrototypeOf(current);
+        }
+      }
+
+      fields[fieldName] = {
+        type: fieldType,
+        ...(targetClass && { target: targetClass.name }),
+        ...(isArray && { array: true }),
+      };
+    }
+  }
+
+  return fields;
+}
+
+// ============================================================================
+// Output generation
+// ============================================================================
+
+function generateModelsBlock(models: Record<string, ModelInfoData>): string {
+  const entries = Object.keys(models)
+    .sort()
+    .map(modelName => {
+      const modelInfo = models[modelName];
+      const fieldEntries = Object.entries(modelInfo.fields)
+        .map(([fn, info]) => {
+          const props: string[] = [`type: '${info.type}'`];
+          if (info.target) {
+            props.push(`target: '${info.target}'`);
+          }
+          if (info.array) {
+            props.push(`array: true`);
+          }
+          return `      ${fn}: { ${props.join(', ')} }`;
+        })
+        .join(',\n');
+
+      const modelProps: string[] = [`name: '${modelName}'`, `persistent: ${modelInfo.persistent}`];
+
+      if (modelInfo.idType) {
+        modelProps.push(`idType: '${modelInfo.idType}'`);
+      }
+
+      modelProps.push(`fields: {\n${fieldEntries}\n    }`);
+      modelProps.push(`actions: {}`);
+
+      return `  ${modelName}: {\n    ${modelProps.join(',\n    ')},\n  }`;
+    })
+    .join(',\n');
+
+  // Add WorkflowType for workflow actions
+  const workflowType = `  WorkflowType: {
+    name: 'WorkflowType',
+    persistent: false,
+    fields: {
+      id: { type: 'scalar' },
+      status: { type: 'scalar' }
+    },
+    actions: {},
+  }`;
+
+  return entries ? `${entries},\n${workflowType}` : workflowType;
+}
+
+function generateActionsBlock(actions: Record<string, ActionInfoData>): string {
+  const entries = Object.keys(actions)
+    .sort()
+    .map(actionName => {
+      const info = actions[actionName];
+      const props: string[] = [];
+      props.push(`operation: '${info.operation}'`);
+      props.push(`type: '${info.type}'`);
+      if (info.paramsRef) {
+        props.push(`params: modelsMetadata['${info.paramsRef}']`);
+      }
+      if (info.returnsRef) {
+        // Check if it's a primitive type (String, Number, Boolean, Date)
+        const isPrimitive = ['String', 'Number', 'Boolean', 'Date'].includes(info.returnsRef);
+        if (isPrimitive) {
+          // For primitive types, don't reference modelsMetadata (it doesn't exist)
+          // The frontend doesn't need field expansion for primitives anyway
+          props.push(`returns: { name: '${info.returnsRef}', persistent: false, fields: {}, actions: {} }`);
+        } else {
+          props.push(`returns: modelsMetadata['${info.returnsRef}']`);
+        }
+      } else if (info.returnsRefs) {
+        const refs = info.returnsRefs
+          .map(r => {
+            const isPrimitive = ['String', 'Number', 'Boolean', 'Date'].includes(r);
+            return isPrimitive
+              ? `{ name: '${r}', persistent: false, fields: {}, actions: {} }`
+              : `modelsMetadata['${r}']`;
+          })
+          .join(', ');
+        props.push(`returns: [${refs}]`);
+      }
+      if (info.modelRef) {
+        props.push(`model: '${info.modelRef}'`);
+      }
+      if (info.label) {
+        props.push(`label: '${info.label}'`);
+      }
+      if (info.isWorkflow !== undefined) {
+        props.push(`isWorkflow: ${info.isWorkflow}`);
+      }
+      if (info.bulk) {
+        props.push(`bulk: ${info.bulk}`);
+      }
+      if (info.blockingExecution !== undefined) {
+        props.push(`blockingExecution: ${info.blockingExecution}`);
+      }
+      if (info.successMessage) {
+        props.push(`successMessage: '${info.successMessage}'`);
+      }
+      if (info.errorMessage) {
+        props.push(`errorMessage: '${info.errorMessage}'`);
+      }
+      return `  ${actionName}: {\n    ${props.join(',\n    ')},\n  }`;
+    })
+    .join(',\n');
+
+  return entries;
+}
+
+function generateModelActionWiring(actions: Record<string, ActionInfoData>): string {
+  // Group actions by model
+  const actionsByModel: Record<string, string[]> = {};
+  for (const [actionName, info] of Object.entries(actions)) {
+    if (info.modelRef && (info.type === 'model' || info.type === 'object')) {
+      if (!actionsByModel[info.modelRef]) {
+        actionsByModel[info.modelRef] = [];
+      }
+      actionsByModel[info.modelRef].push(actionName);
+    }
+  }
+
+  const lines: string[] = [];
+  for (const [modelName, actionNames] of Object.entries(actionsByModel).sort(([a], [b]) => a.localeCompare(b))) {
+    const actionEntries = actionNames
+      .sort()
+      .map(name => `  ${name}: actionsMetadata['${name}']`)
+      .join(',\n');
+    lines.push(`modelsMetadata['${modelName}'].actions = {\n${actionEntries},\n};`);
+  }
+
+  return lines.join('\n\n');
+}
+
+function generateOutputFile(models: Record<string, ModelInfoData>, actions: Record<string, ActionInfoData>): string {
+  const modelsBlock = generateModelsBlock(models);
+  const actionsBlock = generateActionsBlock(actions);
+  const wiringBlock = generateModelActionWiring(actions);
+
+  return `/**
+ * Models & Actions Metadata - Auto-generated by Slingr CLI
+ *
+ * This file provides model field metadata and action metadata for use by
+ * the QueryBuilder, OperationBuilder, and other framework components.
+ *
+ * DO NOT EDIT THIS FILE MANUALLY - regenerate with: slingr gql generate-sdk
+ */
+
+import type {
+  ModelsMetadata,
+  ActionsMetadata,
+} from '@slingr/framework-frontend';
+
+// Phase 1: Models (actions populated in phase 3)
+export const modelsMetadata: ModelsMetadata = {
+${modelsBlock}
+};
+
+// Phase 2: Actions (reference models directly)
+export const actionsMetadata = {
+${actionsBlock}
+} satisfies ActionsMetadata;
+
+// Augment global registry so \`ActionName\` (from @slingr/framework-frontend) resolves
+// to a specific union of action name literals rather than plain \`string\`.
+declare global {
+  interface SlingrActionRegistry extends Record<keyof typeof actionsMetadata, true> {}
+}
+
+// Phase 3: Wire model → action references (model + object actions only)
+${wiringBlock}
+`;
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+
+export async function generateMetadataFile() {
+  try {
+    console.log('🔄 Generating metadata from model/action decorators...');
+
+    // Dynamic import to avoid compile-time dependency on @slingr/framework-backend
+    // This script runs in the user's backend context where @slingr/framework-backend is installed
+    // @ts-ignore
+    const slingrFramework: any = await import('@slingr/framework-backend');
+    const { getAllModels, getAllActions, getAllFieldNames } = slingrFramework;
+
+    // Extract model metadata
+    const allModels = getAllModels();
+    const modelsMetadata: Record<string, ModelInfoData> = {};
+
+    for (const modelClass of allModels) {
+      const fields = extractModelFields(modelClass, getAllFieldNames);
+      const dataSource = Reflect.getMetadata('model:dataSource', modelClass);
+      const isPersistent = !!dataSource;
+
+      if (Object.keys(fields).length > 0) {
+        const metadata: ModelInfoData = {
+          fields,
+          persistent: isPersistent,
+        };
+
+        if (isPersistent) {
+          const fieldNames = getAllFieldNames(modelClass);
+          const idType = detectIdType(modelClass, fieldNames);
+          if (idType) {
+            metadata.idType = idType;
+          }
+        }
+
+        modelsMetadata[modelClass.name] = metadata;
+      }
+    }
+
+    // Extract action metadata (only api: 'gql')
+    const allActions = getAllActions();
+    const actionsMetadata: Record<string, ActionInfoData> = {};
+
+    for (const { actionClass, options, actionType } of allActions) {
+      if (options.api !== 'gql') {
+        continue;
+      }
+
+      // Ensure params model is in modelsMetadata
+      if (options.params && !modelsMetadata[options.params.name]) {
+        const fields = extractModelFields(options.params, getAllFieldNames);
+        const dataSource = Reflect.getMetadata('model:dataSource', options.params);
+        const isPersistent = !!dataSource;
+
+        if (Object.keys(fields).length > 0) {
+          const metadata: ModelInfoData = {
+            fields,
+            persistent: isPersistent,
+          };
+
+          if (isPersistent) {
+            const fieldNames = getAllFieldNames(options.params);
+            const idType = detectIdType(options.params, fieldNames);
+            if (idType) {
+              metadata.idType = idType;
+            }
+          }
+
+          modelsMetadata[options.params.name] = metadata;
+        }
+      }
+
+      // Ensure returns model(s) are in modelsMetadata
+      const returnsArr = Array.isArray(options.returns) ? options.returns : options.returns ? [options.returns] : [];
+      for (const ret of returnsArr) {
+        if (!modelsMetadata[ret.name]) {
+          const fields = extractModelFields(ret, getAllFieldNames);
+          const dataSource = Reflect.getMetadata('model:dataSource', ret);
+          const isPersistent = !!dataSource;
+
+          if (Object.keys(fields).length > 0) {
+            const metadata: ModelInfoData = {
+              fields,
+              persistent: isPersistent,
+            };
+
+            if (isPersistent) {
+              const fieldNames = getAllFieldNames(ret);
+              const idType = detectIdType(ret, fieldNames);
+              if (idType) {
+                metadata.idType = idType;
+              }
+            }
+
+            modelsMetadata[ret.name] = metadata;
+          }
+        }
+      }
+
+      // Extract UI options (handle both single object and contextual array)
+      const uiOptions = Array.isArray(options.ui) ? options.ui[0] : options.ui;
+
+      const isWorkflow = options.workflow === true;
+      const isBulk = options.bulk === true || uiOptions?.bulk === true;
+      // Default blockingExecution to true for workflow and bulk actions — both block the UI by design
+      const isBlockingByDefault = isWorkflow || isBulk;
+      const blockingExecution = uiOptions?.blockingExecution ?? isBlockingByDefault;
+
+      const info: ActionInfoData = {
+        operation: options.type === 'read' ? 'query' : 'mutation',
+        type: actionType,
+        label: uiOptions?.label,
+        isWorkflow,
+        blockingExecution,
+        successMessage: uiOptions?.successMessage,
+        errorMessage: uiOptions?.errorMessage,
+      };
+      if (isBulk) {
+        info.bulk = true;
+      }
+
+      if (options.params) {
+        info.paramsRef = options.params.name;
+      }
+
+      if (options.returns) {
+        // For workflows, the actual GraphQL return type is WorkflowType (not the declared type)
+        if (options.workflow === true) {
+          info.returnsRef = 'WorkflowType';
+        } else if (Array.isArray(options.returns)) {
+          info.returnsRefs = options.returns.map((cls: Function) => cls.name);
+        } else {
+          info.returnsRef = options.returns.name;
+        }
+      }
+
+      if (options.model) {
+        info.modelRef = options.model.name;
+      }
+
+      actionsMetadata[actionClass.name] = info;
+    }
+
+    // Generate output
+    const outputContent = generateOutputFile(modelsMetadata, actionsMetadata);
+
+    // Write to frontend/generated/gql/metadata.ts
+    const frontendPath = path.resolve(process.cwd(), '..', 'frontend');
+    const outputDir = path.join(frontendPath, 'generated', 'gql');
+    const outputPath = path.join(outputDir, 'metadata.ts');
+
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    fs.writeFileSync(outputPath, outputContent, 'utf8');
+
+    const modelCount = Object.keys(modelsMetadata).length;
+    const actionCount = Object.keys(actionsMetadata).length;
+    const fieldCount = Object.values(modelsMetadata).reduce(
+      (sum, modelInfo) => sum + Object.keys(modelInfo.fields).length,
+      0
+    );
+
+    console.log(`   Found ${modelCount} models with ${fieldCount} fields and ${actionCount} actions`);
+    console.log(`✅ Metadata generated: ${outputPath}`);
+  } catch (error: any) {
+    console.error(`❌ Failed to generate metadata: ${error.message}`);
+    console.error(error);
+    process.exit(1);
+  }
+}

package/dist/scripts/generate-schema.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Script to generate GraphQL schema from slingr-framework
+ * Script to generate GraphQL schema from @slingr/framework-backend
  * This script is executed in the context of a user's Slingr application
  *
  * By default, the script generates the schema and exits immediately.