@constructive-io/cli 5.6.22 → 5.6.23

package/README.md

@@ -58,55 +58,26 @@ cnc explorer --origin http://localhost:3000
 
 ### `cnc codegen`
 
-Generate TypeScript types, operations, and SDK from a GraphQL schema.
+Generate TypeScript types, operations, and SDK from a GraphQL schema or endpoint.
 
 ```bash
-# From SDL file
-cnc codegen --schema ./schema.graphql --out ./codegen
+# From endpoint
+cnc codegen --endpoint http://localhost:5555/graphql --out ./codegen
 
-# From endpoint with Host override
-cnc codegen --endpoint http://localhost:3000/graphql --headerHost meta8.localhost --out ./codegen
+# From database
+cnc codegen --database constructive_db --out ./codegen --verbose
 ```
 
 **Options:**
 
-- `--schema <path>` - Schema SDL file path
-- `--endpoint <url>` - GraphQL endpoint to fetch schema via introspection
-- `--headerHost <host>` - Optional Host header for endpoint requests
-- `--auth <token>` - Optional Authorization header value
-- `--header "Name: Value"` - Optional HTTP header (repeatable)
-- `--out <dir>` - Output root directory (default: graphql/codegen/dist)
-- `--format <gql|ts>` - Document format (default: gql)
-- `--convention <style>` - Filename convention (dashed|underscore|camelcase|camelUpper)
-- `--emitTypes <bool>` - Emit types (default: true)
-- `--emitOperations <bool>` - Emit operations (default: true)
-- `--emitSdk <bool>` - Emit SDK (default: true)
-- `--config <path>` - Config file (JSON/YAML)
-
-**Config file example (`codegen.json`):**
-
-```json
-{
-  "input": {
-    "schema": "./schema.graphql",
-    "headers": { "Host": "meta8.localhost" }
-  },
-  "output": {
-    "root": "graphql/codegen/dist"
-  },
-  "documents": {
-    "format": "gql",
-    "convention": "dashed",
-    "excludePatterns": [".*Module$"]
-  },
-  "features": {
-    "emitTypes": true,
-    "emitOperations": true,
-    "emitSdk": true,
-    "emitReactQuery": true
-  }
-}
-```
+- `--endpoint <url>` - GraphQL endpoint URL
+- `--auth <token>` - Authorization header value (e.g., "Bearer 123")
+- `--out <dir>` - Output directory (default: graphql/codegen/dist)
+- `--dry-run` - Preview without writing files
+- `--verbose` - Verbose output
+
+- `--database <name>` - Database override for DB mode (defaults to PGDATABASE)
+- `--schemas <list>` - Comma-separated schemas (required unless using --endpoint)
 
 ### `cnc get-graphql-schema`
 
@@ -123,7 +94,7 @@ cnc get-graphql-schema --endpoint http://localhost:3000/graphql --out ./schema.g
 **Options:**
 
 - `--database <name>` - Database name (for programmatic builder)
-- `--schemas <list>` - Comma-separated schemas to include
+- `--schemas <list>` - Comma-separated schemas to include (required unless using --endpoint)
 - `--endpoint <url>` - GraphQL endpoint to fetch schema via introspection
 - `--headerHost <host>` - Optional Host header for endpoint requests
 - `--auth <token>` - Optional Authorization header value

package/commands/codegen.js

@@ -1,6 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const graphql_server_1 = require("@constructive-io/graphql-server");
 const generate_1 = require("@constructive-io/graphql-codegen/cli/commands/generate");
+const graphql_env_1 = require("@constructive-io/graphql-env");
 const usage = `
 Constructive GraphQL Codegen:
 
@@ -14,29 +51,63 @@ Options:
   --out <dir>                Output directory (default: graphql/codegen/dist)
   --dry-run                  Preview without writing files
   -v, --verbose              Verbose output
+
+  --database <name>          Database override for DB mode (defaults to PGDATABASE)
+  --schemas <list>           Comma-separated schemas (required for DB mode)
 `;
 exports.default = async (argv, _prompter, _options) => {
     if (argv.help || argv.h) {
         console.log(usage);
         process.exit(0);
     }
-    const endpoint = argv.endpoint || '';
+    const endpointArg = argv.endpoint || '';
     const outDir = argv.out || 'codegen';
     const auth = argv.auth || '';
     const configPath = argv.config || '';
     const dryRun = !!(argv['dry-run'] || argv.dryRun);
     const verbose = !!(argv.verbose || argv.v);
-    const result = await (0, generate_1.generateCommand)({
-        config: configPath,
-        endpoint,
-        output: outDir,
-        authorization: auth,
-        verbose,
-        dryRun,
-    });
-    if (!result.success) {
-        console.error('x', result.message);
+    const selectedDb = argv.database || undefined;
+    const options = selectedDb ? (0, graphql_env_1.getEnvOptions)({ pg: { database: selectedDb } }) : (0, graphql_env_1.getEnvOptions)();
+    const schemasArg = argv.schemas || '';
+    const runGenerate = async ({ endpoint, schema }) => {
+        const result = await (0, generate_1.generateCommand)({
+            config: configPath || undefined,
+            endpoint,
+            schema,
+            output: outDir,
+            authorization: auth || undefined,
+            verbose,
+            dryRun,
+        });
+        if (!result.success) {
+            console.error(result.message);
+            if (result.errors?.length)
+                result.errors.forEach(e => console.error('  -', e));
+            process.exit(1);
+        }
+        console.log(result.message);
+        if (result.filesWritten?.length) {
+            result.filesWritten.forEach(f => console.log(f));
+        }
+    };
+    if (endpointArg) {
+        await runGenerate({ endpoint: endpointArg });
+        return;
+    }
+    if (!schemasArg.trim()) {
+        console.error('Error: --schemas is required when building from database. Provide a comma-separated list of schemas.');
         process.exit(1);
     }
-    console.log('[ok]', result.message);
+    const schemas = schemasArg.split(',').map((s) => s.trim()).filter(Boolean);
+    await fs.promises.mkdir(outDir, { recursive: true });
+    const sdl = await (0, graphql_server_1.buildSchemaSDL)({
+        database: options.pg.database,
+        schemas,
+        graphile: {
+            pgSettings: async () => ({ role: 'administrator' }),
+        },
+    });
+    const schemaPath = path.join(outDir, 'schema.graphql');
+    await fs.promises.writeFile(schemaPath, sdl, 'utf-8');
+    await runGenerate({ schema: schemaPath });
 };

package/commands.js

@@ -16,7 +16,7 @@ const createCommandMap = () => {
         server: server_1.default,
         explorer: explorer_1.default,
         'get-graphql-schema': get_graphql_schema_1.default,
-        codegen: codegen_1.default
+        codegen: codegen_1.default,
     };
 };
 const commands = async (argv, prompter, options) => {

package/esm/commands/codegen.js

@@ -1,4 +1,8 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { buildSchemaSDL } from '@constructive-io/graphql-server';
 import { generateCommand } from '@constructive-io/graphql-codegen/cli/commands/generate';
+import { getEnvOptions } from '@constructive-io/graphql-env';
 const usage = `
 Constructive GraphQL Codegen:
 
@@ -12,29 +16,63 @@ Options:
   --out <dir>                Output directory (default: graphql/codegen/dist)
   --dry-run                  Preview without writing files
   -v, --verbose              Verbose output
+
+  --database <name>          Database override for DB mode (defaults to PGDATABASE)
+  --schemas <list>           Comma-separated schemas (required for DB mode)
 `;
 export default async (argv, _prompter, _options) => {
     if (argv.help || argv.h) {
         console.log(usage);
         process.exit(0);
     }
-    const endpoint = argv.endpoint || '';
+    const endpointArg = argv.endpoint || '';
     const outDir = argv.out || 'codegen';
     const auth = argv.auth || '';
     const configPath = argv.config || '';
     const dryRun = !!(argv['dry-run'] || argv.dryRun);
     const verbose = !!(argv.verbose || argv.v);
-    const result = await generateCommand({
-        config: configPath,
-        endpoint,
-        output: outDir,
-        authorization: auth,
-        verbose,
-        dryRun,
-    });
-    if (!result.success) {
-        console.error('x', result.message);
+    const selectedDb = argv.database || undefined;
+    const options = selectedDb ? getEnvOptions({ pg: { database: selectedDb } }) : getEnvOptions();
+    const schemasArg = argv.schemas || '';
+    const runGenerate = async ({ endpoint, schema }) => {
+        const result = await generateCommand({
+            config: configPath || undefined,
+            endpoint,
+            schema,
+            output: outDir,
+            authorization: auth || undefined,
+            verbose,
+            dryRun,
+        });
+        if (!result.success) {
+            console.error(result.message);
+            if (result.errors?.length)
+                result.errors.forEach(e => console.error('  -', e));
+            process.exit(1);
+        }
+        console.log(result.message);
+        if (result.filesWritten?.length) {
+            result.filesWritten.forEach(f => console.log(f));
+        }
+    };
+    if (endpointArg) {
+        await runGenerate({ endpoint: endpointArg });
+        return;
+    }
+    if (!schemasArg.trim()) {
+        console.error('Error: --schemas is required when building from database. Provide a comma-separated list of schemas.');
         process.exit(1);
     }
-    console.log('[ok]', result.message);
+    const schemas = schemasArg.split(',').map((s) => s.trim()).filter(Boolean);
+    await fs.promises.mkdir(outDir, { recursive: true });
+    const sdl = await buildSchemaSDL({
+        database: options.pg.database,
+        schemas,
+        graphile: {
+            pgSettings: async () => ({ role: 'administrator' }),
+        },
+    });
+    const schemaPath = path.join(outDir, 'schema.graphql');
+    await fs.promises.writeFile(schemaPath, sdl, 'utf-8');
+    await runGenerate({ schema: schemaPath });
 };

package/esm/commands.js

@@ -10,7 +10,7 @@ const createCommandMap = () => {
         server,
         explorer,
         'get-graphql-schema': getGraphqlSchema,
-        codegen
+        codegen,
     };
 };
 export const commands = async (argv, prompter, options) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/cli",
-  "version": "5.6.22",
+  "version": "5.6.23",
   "author": "Constructive <developers@constructive.io>",
   "description": "Constructive CLI",
   "main": "index.js",
@@ -76,5 +76,5 @@
     "postgres",
     "graphile"
   ],
-  "gitHead": "15e8f92ee6ec7bfebd6647dec743e4235b0362ac"
+  "gitHead": "d95f70a0f2abc3ecbece7dac188abf2da91cd5d5"
 }