@slingr/cli 0.0.3 → 0.0.4

package/dist/scripts/generate-schema.ts

@@ -1,143 +1,258 @@
-#!/usr/bin/env node
-/**
- * Script to generate GraphQL schema from slingr-framework
- * This script is executed in the context of a user's Slingr application
- *
- * By default, the script generates the schema and exits immediately.
- * Use --no-exit flag to start Apollo Server for schema exploration.
- */
-
-import fs from 'fs';
-import path from 'path';
-import { pathToFileURL } from 'url';
-
-async function generateSchema() {
-  try {
-    console.log('🔄 Generating GraphQL schema from your Slingr application...');
-
-    // IMPORTANT: Import actions BEFORE importing slingr-framework
-    // This ensures action decorators are executed before the schema is built
-
-    // Try to load the compiled JavaScript version first, then fallback to TypeScript
-    // Note: TypeScript compilation with rootDir inferred from src/ will output to dist/actions/
-    // (without the src folder in the path)
-    let actionsIndexPath = path.join(process.cwd(), 'dist', 'actions', 'index.js');
-    let usingCompiledVersion = true;
-    let hasActions = false;
-
-    if (fs.existsSync(actionsIndexPath)) {
-      hasActions = true;
-    } else {
-      // Also check the alternative path (dist/src/actions/index.js) for backwards compatibility
-      const altActionsIndexPath = path.join(process.cwd(), 'dist', 'src', 'actions', 'index.js');
-      if (fs.existsSync(altActionsIndexPath)) {
-        actionsIndexPath = altActionsIndexPath;
-        hasActions = true;
-      } else {
-        // Fallback to TypeScript source
-        actionsIndexPath = path.join(process.cwd(), 'src', 'actions', 'index.ts');
-        usingCompiledVersion = false;
-
-        if (fs.existsSync(actionsIndexPath)) {
-          hasActions = true;
-          console.log(
-            '⚠️  TypeScript source files detected. For best compatibility, run "npm run build" to compile your application first.'
-          );
-        } else {
-          // Check if actions directory exists at all
-          const actionsDir = path.join(process.cwd(), 'src', 'actions');
-          if (fs.existsSync(actionsDir)) {
-            console.log(
-              '⚠️  Actions directory found but no index file. Please ensure src/actions/index.ts exists or run "slingr run" to generate it automatically.'
-            );
-          } else {
-            console.log('ℹ️  No actions directory found. Schema will be generated with framework base types only.');
-          }
-          hasActions = false;
-        }
-      }
-    }
-
-    if (hasActions) {
-      console.log(`📦 Loading actions from ${usingCompiledVersion ? 'compiled' : 'source'} files...`);
-
-      // If using TypeScript files, show a warning and try to continue
-      if (!usingCompiledVersion) {
-        throw new Error(
-          'TypeScript source files found but not compiled. Please run "npm run build" to compile your application first, then try again.'
-        );
-      }
-
-      // Import the actions index which will register all actions via @Action decorators
-      // Convert Windows paths to file:// URLs for ESM compatibility
-      const actionsIndexUrl = pathToFileURL(actionsIndexPath).href;
-      await import(actionsIndexUrl);
-    } else {
-      console.log('📦 No actions to load. Generating schema with framework base types...');
-    } // Import framework functions and printSchema from slingr-framework
-    // We must use printSchema from the same GraphQL instance as the framework
-    // to avoid "Cannot use GraphQLType from another module or realm" errors
-    const slingrFramework = await import('slingr-framework');
-    const { getGraphQLSchema, rebuildGraphQLSchema, printSchema } = slingrFramework;
-
-    // Force rebuild the schema to include all registered actions
-    rebuildGraphQLSchema();
-    const schema = getGraphQLSchema();
-
-    if (!schema) {
-      throw new Error('Could not generate GraphQL schema. Please ensure slingr-framework is properly installed.');
-    }
-
-    const schemaString = printSchema(schema);
-
-    // Ensure generated/gql directory exists
-    const generatedDir = path.join(process.cwd(), 'generated', 'gql');
-    if (!fs.existsSync(generatedDir)) {
-      fs.mkdirSync(generatedDir, { recursive: true });
-    }
-
-    // Write schema to file
-    const schemaFilePath = path.join(generatedDir, 'schema.graphql');
-    fs.writeFileSync(schemaFilePath, schemaString, 'utf8');
-
-    console.log(`✅ GraphQL schema generated successfully at: ${schemaFilePath}`);
-
-    // Show a preview of the generated schema
-    const lines = schemaString.split('\n');
-    if (lines.length > 0) {
-      console.log('\n📋 Schema preview:');
-      console.log(lines.slice(0, Math.min(15, lines.length)).join('\n'));
-      if (lines.length > 15) {
-        console.log(`... (${lines.length - 15} more lines)`);
-      }
-    }
-
-    // Check for --no-exit parameter
-    const noExit = process.argv.includes('--no-exit');
-    if (noExit) {
-      console.log('\n Starting Apollo Server to explore the schema...');
-      console.log('💡 Remove --no-exit parameter to exit immediately after generating schema.');
-
-      // Start Apollo Server for schema exploration
-      const { startGraphQLServer } = slingrFramework;
-      await startGraphQLServer({
-        port: 4000,
-        enableExplorer: true,
-      });
-
-      console.log('🌐 Apollo Explorer available at: http://localhost:4000/graphql');
-      console.log('📖 GraphQL schema introspection enabled');
-      console.log('⏹️  Press Ctrl+C to stop the server');
-    } else {
-      console.log('\n✅ Schema generation completed. Script will terminate now.');
-      console.log('💡 Use --no-exit parameter to start Apollo Server and explore the schema.');
-      process.exit(0);
-    }
-  } catch (error: any) {
-    console.error(`Failed to generate schema: ${error.message}`);
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-generateSchema();
+#!/usr/bin/env node
+/**
+ * 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.
+ * Use --no-exit flag to start Apollo Server for schema exploration.
+ */
+
+import fs from 'fs';
+import path from 'path';
+// Load generated view type registries if they exist so declare global augmentations are active
+// during schema compilation. The file may not exist yet on the first run.
+const generatedViewsPath = path.join(process.cwd(), 'generated', 'views');
+if (fs.existsSync(generatedViewsPath + '.ts') || fs.existsSync(generatedViewsPath + '.js')) {
+  require(generatedViewsPath);
+}
+// @ts-ignore - temp-generate-metadata.ts is copied at runtime by the CLI
+import { generateMetadataFile } from './temp-generate-metadata';
+
+/**
+ * Load data sources from src/dataSources directory.
+ * Loads directly from TypeScript source files using ts-node.
+ */
+async function loadDataSources() {
+  const dataSourcesPath = path.join(process.cwd(), 'src', 'dataSources');
+
+  if (!fs.existsSync(dataSourcesPath)) {
+    console.log('ℹ️  No dataSources directory found. Schema will be generated without CRUD operations.');
+    return;
+  }
+
+  console.log('📦 Loading data sources from TypeScript source files...');
+
+  // Get all data source files
+  const files = fs.readdirSync(dataSourcesPath).filter(file => file.endsWith('.ts') && !file.endsWith('.d.ts'));
+
+  if (files.length === 0) {
+    console.log('ℹ️  No data source files found.');
+    return;
+  }
+
+  // Import each data source file using CommonJS require
+  for (const file of files) {
+    const filePath = path.join(dataSourcesPath, file);
+    require(filePath);
+  }
+
+  console.log(`✅ Loaded ${files.length} data source(s)`);
+}
+
+/**
+ * Recursively collect all files matching an extension from a directory.
+ */
+function collectFilesRecursively(dir: string, extension: string): string[] {
+  const results: string[] = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFilesRecursively(fullPath, extension));
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith(extension) &&
+      !entry.name.endsWith('.d.ts') &&
+      !/\.test\.|\.spec\./i.test(entry.name)
+    ) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Load model files from src/data directory (including subdirectories).
+ * Loads directly from TypeScript source files using tsx to avoid double decorator execution.
+ * @returns Array of loaded model classes
+ */
+async function loadModels(): Promise<Array<new (...args: any[]) => any>> {
+  const loadedModels: Array<new (...args: any[]) => any> = [];
+
+  const modelsPath = path.join(process.cwd(), 'src', 'data');
+
+  if (!fs.existsSync(modelsPath)) {
+    console.log('ℹ️  No data directory found. Schema will be generated without model CRUD operations.');
+    return loadedModels;
+  }
+
+  console.log('📦 Loading models from TypeScript source files...');
+
+  // Recursively get all model files, excluding tests/specs and declaration files
+  const files = collectFilesRecursively(modelsPath, '.ts');
+
+  if (files.length === 0) {
+    console.log('ℹ️  No model files found.');
+    return loadedModels;
+  }
+
+  // Import each model file (which will trigger @DataModel decorators and register CRUD operations)
+  for (const filePath of files) {
+    const moduleExports = require(filePath);
+
+    // Extract model classes from the module exports
+    for (const exportName of Object.keys(moduleExports)) {
+      const exported = moduleExports[exportName];
+      if (typeof exported === 'function' && exported.prototype) {
+        loadedModels.push(exported as new (...args: any[]) => any);
+      }
+    }
+  }
+
+  console.log(`✅ Loaded ${files.length} model(s)`);
+
+  return loadedModels;
+}
+
+async function generateSchema() {
+  try {
+    console.log('🔄 Generating GraphQL schema from your Slingr application...');
+
+    // Dynamic import to avoid compile-time dependency on @slingr/framework-backend
+    // This script runs in the user's project context where @slingr/framework-backend is installed
+    // @ts-ignore
+    const slingrFramework = await import('@slingr/framework-backend');
+    const { generateActionsIndex, getGraphQLSchema, printSchema, rebuildGraphQLSchema, startGraphQLServer } =
+      slingrFramework;
+
+    // Import framework functions first to get access to rebuildGraphQLSchema
+    // We must use printSchema from the same GraphQL instance as the framework
+    // to avoid "Cannot use GraphQLType from another module or realm" errors
+
+    // Destructure directly from the imported module (works for both ESM and CJS)
+    // The named exports are available directly on the module namespace object
+
+    // Rebuild the schema FIRST to clear any previous state before loading anything
+    // This ensures we start with a clean slate
+    rebuildGraphQLSchema();
+
+    // IMPORTANT: Load actions AFTER rebuilding the schema
+    // When actions are imported, they will register themselves in the clean schema builder
+
+    // Check if actions directory exists
+    const actionsDir = path.join(process.cwd(), 'src', 'actions');
+    let hasActions = false;
+
+    if (fs.existsSync(actionsDir)) {
+      // Generate the actions index at generated/actions/index.ts
+      console.log('📦 Generating actions index...');
+
+      // Generate the actions index
+      await generateActionsIndex(process.cwd(), 'src/actions');
+
+      // Check if the generated index exists
+      const generatedActionsIndexPath = path.resolve(process.cwd(), 'generated', 'actions', 'index.ts');
+      if (fs.existsSync(generatedActionsIndexPath)) {
+        hasActions = true;
+        console.log('📦 Loading actions from generated TypeScript index...');
+
+        require(generatedActionsIndexPath);
+      } else {
+        console.log('⚠️  Failed to generate actions index.');
+        hasActions = false;
+      }
+    } else {
+      console.log('ℹ️  No actions directory found. Schema will be generated with framework base types only.');
+    }
+
+    if (!hasActions) {
+      console.log('📦 No actions to load. Generating schema with framework base types...');
+    }
+
+    // Load data sources and models (which will register CRUD operations)
+
+    // Import framework functions and printSchema from slingr-framework
+    // We must use printSchema from the same GraphQL instance as the framework
+    // to avoid "Cannot use GraphQLType from another module or realm" errors
+    const { registerAllUiGraphQL, registerCrudOperations, generateCrudActions } = slingrFramework;
+
+    // Load data sources and models
+    // Actions will be generated but NOT registered in GraphQL during model import
+    await loadDataSources();
+    const loadedModels = await loadModels();
+    console.log('📦 Registering UI operations for all UI-enabled models...');
+    await registerAllUiGraphQL();
+    console.log('✅ UI operations registered');
+
+    // Register CRUD GraphQL operations for models with crud configuration
+    if (loadedModels.length > 0) {
+      for (const modelClass of loadedModels) {
+        const modelOptions = (Reflect as any).getMetadata('model:options', modelClass);
+        const crudOptions = modelOptions?.crud;
+
+        if (crudOptions && crudOptions.api === 'gql' && crudOptions.generate) {
+          const dataSource = (Reflect as any).getMetadata('model:dataSource', modelClass);
+          if (dataSource) {
+            // First generate CRUD actions (normally done by decorator)
+            generateCrudActions(modelClass, dataSource, crudOptions);
+            // Then register GraphQL operations
+            registerCrudOperations(modelClass);
+          }
+        }
+      }
+    }
+
+    // Get schema (which will build it with all registered operations)
+    const schema = getGraphQLSchema();
+    if (!schema) {
+      throw new Error('Could not generate GraphQL schema. Please ensure @slingr/framework-backend is properly installed.');
+    }
+
+    const schemaString = printSchema(schema);
+
+    // Ensure generated/gql directory exists
+    const generatedDir = path.join(process.cwd(), 'generated', 'gql');
+    if (!fs.existsSync(generatedDir)) {
+      fs.mkdirSync(generatedDir, { recursive: true });
+    }
+
+    // Write schema to file
+    const schemaFilePath = path.join(generatedDir, 'schema.graphql');
+    try {
+      fs.writeFileSync(schemaFilePath, schemaString, 'utf8');
+    } catch (writeError: unknown) {
+      const msg = writeError instanceof Error ? writeError.message : String(writeError);
+      console.error(`❌ Failed to write schema file at ${schemaFilePath}: ${msg}`);
+      throw writeError instanceof Error ? writeError : new Error(msg);
+    }
+
+    // Verify file creation and log size
+    try {
+      const stats = fs.statSync(schemaFilePath);
+      console.log(`✅ GraphQL schema written: ${schemaFilePath} (${stats.size} bytes)`);
+    } catch (statError: unknown) {
+      const msg = statError instanceof Error ? statError.message : String(statError);
+      console.warn(`⚠️  Schema file write succeeded but verification failed: ${msg}`);
+      console.log(`ℹ️  Please check that the path exists and you have write permissions: ${schemaFilePath}`);
+    }
+
+    // Show a preview of the generated schema
+    const lines = schemaString.split('\n');
+    if (lines.length > 0) {
+      console.log('\n📋 Schema preview:');
+      console.log(lines.slice(0, Math.min(15, lines.length)).join('\n'));
+      if (lines.length > 15) {
+        console.log(`... (${lines.length - 15} more lines)`);
+      }
+    }
+    await generateMetadataFile();
+    console.log('\n✅ Schema generation completed. Script will terminate now.');
+    process.exit(0);
+  } catch (error: any) {
+    console.error(`Failed to generate schema: ${error.message}`);
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+generateSchema();

package/dist/templates/.env.template

@@ -0,0 +1,23 @@
+# Slingr Application Configuration
+# This file contains environment-specific configuration for your Slingr app.
+# Copy this file to .env and customize the values as needed.
+
+# GraphQL Server Configuration
+GRAPHQL_HOST=localhost
+GRAPHQL_PORT=3000
+GRAPHQL_ENABLE_EXPLORER=true
+
+# Note: These values can be overridden by:
+# 1. app.configure() method in your code
+# 2. app.run() options parameter
+# Configuration priority: .env < configure() < run(options)
+
+# JWT Configuration
+JWT_SECRET=your-secret-key-change-in-production
+
+# Database Configuration
+DB_HOST=localhost
+DB_PORT=5432
+DB_USER=postgres
+DB_PASSWORD=postgres
+DB_NAME={{APP_NAME}}

package/dist/templates/.firebaserc.template

@@ -0,0 +1,5 @@
+{
+  "projects": {
+    "default": "YOUR_GCP_PROJECT_ID"
+  }
+}