@cxtms/cx-schema 1.7.11 → 1.7.13

package/dist/cli.js

@@ -119,6 +119,7 @@ ${chalk_1.default.bold.yellow('COMMANDS:')}
   ${chalk_1.default.green('publish')}         Publish all modules and workflows to a CX server
   ${chalk_1.default.green('app')}             Manage app manifests (install/upgrade from git, publish to git, list)
   ${chalk_1.default.green('query')}           Run a GraphQL query against the CX server
+  ${chalk_1.default.green('gql')}             Explore GraphQL schema (types, queries, mutations)
   ${chalk_1.default.green('schema')}          Show JSON schema for a component or task
   ${chalk_1.default.green('example')}         Show example YAML for a component or task
   ${chalk_1.default.green('list')}            List available schemas (modules, workflows, tasks)
@@ -336,6 +337,20 @@ ${chalk_1.default.bold.yellow('QUERY COMMANDS:')}
   ${chalk_1.default.gray('# Pass variables as JSON')}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} query my-query.graphql --vars '{"id": 42}'`)}
 
+${chalk_1.default.bold.yellow('GRAPHQL SCHEMA EXPLORATION:')}
+  ${chalk_1.default.gray('# List all queries, mutations, and types')}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql queries`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql mutations`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql types`)}
+
+  ${chalk_1.default.gray('# Filter by name')}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql types --filter audit`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql queries --filter order`)}
+
+  ${chalk_1.default.gray('# Inspect a specific type')}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql type OrderGqlDto`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} gql type AuditChangeEntry`)}
+
 ${chalk_1.default.bold.yellow('VALIDATION TYPES:')}
   ${chalk_1.default.bold('module')}     - CargoXplorer UI module definitions (components, routes, entities)
   ${chalk_1.default.bold('workflow')}   - CargoXplorer workflow definitions (activities, tasks, triggers)
@@ -2282,10 +2297,64 @@ async function runWorkflowUndeploy(uuid, orgOverride) {
     });
     console.log(chalk_1.default.green(`  ✓ Deleted: ${uuid}\n`));
 }
-async function runWorkflowExecute(workflowIdOrFile, orgOverride, variables) {
+async function uploadFileToServer(domain, token, orgId, localPath) {
+    const fileName = path.basename(localPath);
+    const ext = path.extname(localPath).toLowerCase();
+    const contentTypeMap = {
+        '.csv': 'text/csv', '.json': 'application/json', '.xml': 'application/xml',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        '.xls': 'application/vnd.ms-excel', '.pdf': 'application/pdf',
+        '.txt': 'text/plain', '.zip': 'application/zip',
+    };
+    const contentType = contentTypeMap[ext] || 'application/octet-stream';
+    // Step 1: Get presigned upload URL
+    const data = await graphqlRequest(domain, token, `
+    query ($organizationId: Int!, $fileName: String!, $contentType: String!) {
+      uploadUrl(organizationId: $organizationId, fileName: $fileName, contentType: $contentType) {
+        presignedUrl
+        fileUrl
+      }
+    }
+  `, { organizationId: orgId, fileName, contentType });
+    const presignedUrl = data?.uploadUrl?.presignedUrl;
+    const fileUrl = data?.uploadUrl?.fileUrl;
+    if (!presignedUrl || !fileUrl) {
+        throw new Error('Failed to get upload URL from server');
+    }
+    // Step 2: PUT file content to presigned URL
+    const fileContent = fs.readFileSync(localPath);
+    const url = new URL(presignedUrl);
+    const httpModule = url.protocol === 'https:' ? https : http;
+    await new Promise((resolve, reject) => {
+        const req = httpModule.request(url, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': contentType,
+                'Content-Length': fileContent.length,
+                'x-ms-blob-type': 'BlockBlob',
+            },
+        }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => body += chunk);
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`File upload failed (${res.statusCode}): ${body}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(fileContent);
+        req.end();
+    });
+    return fileUrl;
+}
+async function runWorkflowExecute(workflowIdOrFile, orgOverride, variables, fileArgs) {
     if (!workflowIdOrFile) {
         console.error(chalk_1.default.red('Error: Workflow ID or YAML file required'));
-        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} workflow execute <workflowId|file.yaml> [--org <id>] [--vars '{"key":"value"}']`));
+        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} workflow execute <workflowId|file.yaml> [--org <id>] [--vars '{"key":"value"}'] [--file varName=path]`));
         process.exit(2);
     }
     const session = resolveSession();
@@ -2318,6 +2387,28 @@ async function runWorkflowExecute(workflowIdOrFile, orgOverride, variables) {
             process.exit(2);
         }
     }
+    // Process --file args: upload files and set URLs as variables
+    if (fileArgs && fileArgs.length > 0) {
+        if (!vars)
+            vars = {};
+        for (const fileArg of fileArgs) {
+            const eqIdx = fileArg.indexOf('=');
+            if (eqIdx < 1) {
+                console.error(chalk_1.default.red(`Error: --file must be in format varName=path (got: ${fileArg})`));
+                process.exit(2);
+            }
+            const varName = fileArg.substring(0, eqIdx);
+            const filePath = fileArg.substring(eqIdx + 1);
+            if (!fs.existsSync(filePath)) {
+                console.error(chalk_1.default.red(`Error: File not found: ${filePath}`));
+                process.exit(2);
+            }
+            console.log(chalk_1.default.gray(`  Uploading ${path.basename(filePath)}...`));
+            const fileUrl = await uploadFileToServer(domain, token, orgId, filePath);
+            vars[varName] = fileUrl;
+            console.log(chalk_1.default.gray(`  → ${varName} = ${fileUrl}`));
+        }
+    }
     console.log(chalk_1.default.bold.cyan('\n  Workflow Execute\n'));
     console.log(chalk_1.default.gray(`  Server:    ${new URL(domain).hostname}`));
     console.log(chalk_1.default.gray(`  Org:       ${orgId}`));
@@ -3112,6 +3203,169 @@ async function runQuery(queryArg, variables) {
     console.log(JSON.stringify(data, null, 2));
 }
 // ============================================================================
+// GQL Schema Exploration Command
+// ============================================================================
+async function runGql(sub, filter) {
+    if (!sub) {
+        console.error(chalk_1.default.red('Error: subcommand required'));
+        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} gql <queries|mutations|types|type> [name] [--filter <text>]`));
+        process.exit(2);
+    }
+    const session = resolveSession();
+    if (sub === 'type') {
+        if (!filter) {
+            console.error(chalk_1.default.red('Error: type name required'));
+            console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} gql type <TypeName>`));
+            process.exit(2);
+        }
+        await runGqlType(session, filter);
+    }
+    else if (sub === 'queries') {
+        await runGqlRootFields(session, 'queryType', filter);
+    }
+    else if (sub === 'mutations') {
+        await runGqlRootFields(session, 'mutationType', filter);
+    }
+    else if (sub === 'types') {
+        await runGqlTypes(session, filter);
+    }
+    else {
+        console.error(chalk_1.default.red(`Unknown gql subcommand: ${sub}`));
+        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} gql <queries|mutations|types|type> [--filter <text>]`));
+        process.exit(2);
+    }
+}
+function formatGqlType(t) {
+    if (!t)
+        return 'unknown';
+    if (t.kind === 'NON_NULL')
+        return `${formatGqlType(t.ofType)}!`;
+    if (t.kind === 'LIST')
+        return `[${formatGqlType(t.ofType)}]`;
+    return t.name || 'unknown';
+}
+async function runGqlType(session, typeName) {
+    const query = `{
+    __type(name: "${typeName}") {
+      name kind description
+      fields { name description type { name kind ofType { name kind ofType { name kind ofType { name kind } } } } args { name type { name kind ofType { name kind ofType { name kind } } } defaultValue } }
+      inputFields { name type { name kind ofType { name kind ofType { name kind } } } defaultValue }
+      enumValues { name description }
+    }
+  }`;
+    const data = await graphqlRequest(session.domain, session.access_token, query, {});
+    const type = data.__type;
+    if (!type) {
+        console.error(chalk_1.default.red(`Type "${typeName}" not found`));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.bold.cyan(`${type.name}`) + chalk_1.default.gray(` (${type.kind})`));
+    if (type.description)
+        console.log(chalk_1.default.gray(type.description));
+    console.log('');
+    if (type.fields && type.fields.length > 0) {
+        console.log(chalk_1.default.bold.yellow('Fields:'));
+        for (const f of type.fields) {
+            const typeStr = formatGqlType(f.type);
+            let line = `  ${chalk_1.default.green(f.name)}: ${chalk_1.default.cyan(typeStr)}`;
+            if (f.args && f.args.length > 0) {
+                const argsStr = f.args.map((a) => {
+                    const argType = formatGqlType(a.type);
+                    return a.defaultValue ? `${a.name}: ${argType} = ${a.defaultValue}` : `${a.name}: ${argType}`;
+                }).join(', ');
+                line += chalk_1.default.gray(` (${argsStr})`);
+            }
+            if (f.description)
+                line += chalk_1.default.gray(` — ${f.description}`);
+            console.log(line);
+        }
+    }
+    if (type.inputFields && type.inputFields.length > 0) {
+        console.log(chalk_1.default.bold.yellow('Input Fields:'));
+        for (const f of type.inputFields) {
+            const typeStr = formatGqlType(f.type);
+            let line = `  ${chalk_1.default.green(f.name)}: ${chalk_1.default.cyan(typeStr)}`;
+            if (f.defaultValue)
+                line += chalk_1.default.gray(` = ${f.defaultValue}`);
+            console.log(line);
+        }
+    }
+    if (type.enumValues && type.enumValues.length > 0) {
+        console.log(chalk_1.default.bold.yellow('Enum Values:'));
+        for (const v of type.enumValues) {
+            let line = `  ${chalk_1.default.green(v.name)}`;
+            if (v.description)
+                line += chalk_1.default.gray(` — ${v.description}`);
+            console.log(line);
+        }
+    }
+}
+async function runGqlRootFields(session, rootType, filter) {
+    const query = `{
+    __schema {
+      ${rootType} {
+        fields { name description args { name type { name kind ofType { name kind ofType { name kind } } } defaultValue } type { name kind ofType { name kind ofType { name kind } } } }
+      }
+    }
+  }`;
+    const data = await graphqlRequest(session.domain, session.access_token, query, {});
+    const fields = data.__schema?.[rootType]?.fields || [];
+    const filtered = filter
+        ? fields.filter((f) => f.name.toLowerCase().includes(filter.toLowerCase()))
+        : fields;
+    const label = rootType === 'queryType' ? 'Queries' : 'Mutations';
+    console.log(chalk_1.default.bold.yellow(`${label}${filter ? ` (filter: "${filter}")` : ''}:`));
+    console.log('');
+    for (const f of filtered) {
+        const returnType = formatGqlType(f.type);
+        console.log(`  ${chalk_1.default.green(f.name)}: ${chalk_1.default.cyan(returnType)}`);
+        if (f.description)
+            console.log(`    ${chalk_1.default.gray(f.description)}`);
+        if (f.args && f.args.length > 0) {
+            for (const a of f.args) {
+                const argType = formatGqlType(a.type);
+                const def = a.defaultValue ? chalk_1.default.gray(` = ${a.defaultValue}`) : '';
+                console.log(`    ${chalk_1.default.white(a.name)}: ${chalk_1.default.cyan(argType)}${def}`);
+            }
+        }
+        console.log('');
+    }
+    console.log(chalk_1.default.gray(`${filtered.length} ${label.toLowerCase()} found`));
+}
+async function runGqlTypes(session, filter) {
+    const query = `{
+    __schema {
+      types { name kind description }
+    }
+  }`;
+    const data = await graphqlRequest(session.domain, session.access_token, query, {});
+    const types = (data.__schema?.types || [])
+        .filter((t) => !t.name.startsWith('__'))
+        .filter((t) => !filter || t.name.toLowerCase().includes(filter.toLowerCase()));
+    const grouped = {};
+    for (const t of types) {
+        const kind = t.kind || 'OTHER';
+        if (!grouped[kind])
+            grouped[kind] = [];
+        grouped[kind].push(t);
+    }
+    const kindOrder = ['OBJECT', 'INPUT_OBJECT', 'ENUM', 'INTERFACE', 'UNION', 'SCALAR'];
+    for (const kind of kindOrder) {
+        const items = grouped[kind];
+        if (!items || items.length === 0)
+            continue;
+        console.log(chalk_1.default.bold.yellow(`${kind} (${items.length}):`));
+        for (const t of items.sort((a, b) => a.name.localeCompare(b.name))) {
+            let line = `  ${chalk_1.default.green(t.name)}`;
+            if (t.description)
+                line += chalk_1.default.gray(` — ${t.description}`);
+            console.log(line);
+        }
+        console.log('');
+    }
+    console.log(chalk_1.default.gray(`${types.length} types found${filter ? ` matching "${filter}"` : ''}`));
+}
+// ============================================================================
 // Extract Command
 // ============================================================================
 function runExtract(sourceFile, componentName, targetFile, copy) {
@@ -3322,7 +3576,7 @@ function parseArgs(args) {
         reportFormat: 'json'
     };
     // Check for commands
-    const commands = ['validate', 'schema', 'example', 'list', 'help', 'version', 'report', 'init', 'create', 'extract', 'sync-schemas', 'install-skills', 'update', 'setup-claude', 'login', 'logout', 'pat', 'appmodule', 'orgs', 'workflow', 'publish', 'query', 'app'];
+    const commands = ['validate', 'schema', 'example', 'list', 'help', 'version', 'report', 'init', 'create', 'extract', 'sync-schemas', 'install-skills', 'update', 'setup-claude', 'login', 'logout', 'pat', 'appmodule', 'orgs', 'workflow', 'publish', 'query', 'gql', 'app'];
     if (args.length > 0 && commands.includes(args[0])) {
         command = args[0];
         args = args.slice(1);
@@ -3428,6 +3682,14 @@ function parseArgs(args) {
         else if (arg === '--branch' || arg === '-b') {
             options.branch = args[++i];
         }
+        else if (arg === '--file') {
+            if (!options.file)
+                options.file = [];
+            options.file.push(args[++i]);
+        }
+        else if (arg === '--filter') {
+            options.filter = args[++i];
+        }
         else if (arg === '--force') {
             options.force = true;
         }
@@ -4315,7 +4577,7 @@ async function main() {
             await runWorkflowUndeploy(files[1], options.orgId);
         }
         else if (sub === 'execute') {
-            await runWorkflowExecute(files[1], options.orgId, options.vars);
+            await runWorkflowExecute(files[1], options.orgId, options.vars, options.file);
         }
         else if (sub === 'logs') {
             await runWorkflowLogs(files[1], options.orgId, options.from, options.to);
@@ -4354,6 +4616,14 @@ async function main() {
         }
         process.exit(0);
     }
+    // Handle gql command (no schemas needed)
+    if (command === 'gql') {
+        const sub = files[0];
+        // For 'gql type <name>', the type name is in files[1] — use it as filter
+        const filterArg = sub === 'type' ? (files[1] || options.filter) : options.filter;
+        await runGql(sub, filterArg);
+        process.exit(0);
+    }
     // Handle query command (no schemas needed)
     if (command === 'query') {
         await runQuery(files[0], options.vars);