@constructive-sdk/cli 0.25.15 → 0.25.17

package/compute/cli/executor.d.ts

@@ -0,0 +1,100 @@
+export declare const getStore: () => import("appstash").ConfigStore;
+export declare function getClient(contextName?: string): {
+    getAllRecord: import("../orm").GetAllRecordModel;
+    functionApiBinding: import("../orm").FunctionApiBindingModel;
+    functionDeployment: import("../orm").FunctionDeploymentModel;
+    functionGraphRef: import("../orm").FunctionGraphRefModel;
+    functionGraphStore: import("../orm").FunctionGraphStoreModel;
+    functionGraphObject: import("../orm").FunctionGraphObjectModel;
+    functionDeploymentEvent: import("../orm").FunctionDeploymentEventModel;
+    orgFunctionExecutionLog: import("../orm").OrgFunctionExecutionLogModel;
+    functionGraphExecutionOutput: import("../orm").FunctionGraphExecutionOutputModel;
+    functionGraphCommit: import("../orm").FunctionGraphCommitModel;
+    secretDefinition: import("../orm").SecretDefinitionModel;
+    functionExecutionLog: import("../orm").FunctionExecutionLogModel;
+    functionGraphExecutionNodeState: import("../orm").FunctionGraphExecutionNodeStateModel;
+    functionGraph: import("../orm").FunctionGraphModel;
+    orgFunctionInvocation: import("../orm").OrgFunctionInvocationModel;
+    functionInvocation: import("../orm").FunctionInvocationModel;
+    functionGraphExecution: import("../orm").FunctionGraphExecutionModel;
+    functionDefinition: import("../orm").FunctionDefinitionModel;
+    query: {
+        readFunctionGraph: (args: import("../orm/query").ReadFunctionGraphVariables, options?: {
+            select?: Record<string, unknown>;
+        }) => import("../orm").QueryBuilder<{
+            readFunctionGraph: unknown | null;
+        }>;
+    };
+    mutation: {
+        validateFunctionGraph: <S extends import("../orm/input-types").ValidateFunctionGraphPayloadSelect>(args: import("../orm/mutation").ValidateFunctionGraphVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").ValidateFunctionGraphPayloadSelect>) => import("../orm").QueryBuilder<{
+            validateFunctionGraph: import("../orm").InferSelectResult<import("../orm/input-types").ValidateFunctionGraphPayload, S> | null;
+        }>;
+        initEmptyRepo: <S extends import("../orm/input-types").InitEmptyRepoPayloadSelect>(args: import("../orm/mutation").InitEmptyRepoVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").InitEmptyRepoPayloadSelect>) => import("../orm").QueryBuilder<{
+            initEmptyRepo: import("../orm").InferSelectResult<import("../orm/input-types").InitEmptyRepoPayload, S> | null;
+        }>;
+        setDataAtPath: <S extends import("../orm/input-types").SetDataAtPathPayloadSelect>(args: import("../orm/mutation").SetDataAtPathVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").SetDataAtPathPayloadSelect>) => import("../orm").QueryBuilder<{
+            setDataAtPath: import("../orm").InferSelectResult<import("../orm/input-types").SetDataAtPathPayload, S> | null;
+        }>;
+        importDefinitions: <S extends import("../orm/input-types").ImportDefinitionsPayloadSelect>(args: import("../orm/mutation").ImportDefinitionsVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").ImportDefinitionsPayloadSelect>) => import("../orm").QueryBuilder<{
+            importDefinitions: import("../orm").InferSelectResult<import("../orm/input-types").ImportDefinitionsPayload, S> | null;
+        }>;
+        copyGraph: <S extends import("../orm/input-types").CopyGraphPayloadSelect>(args: import("../orm/mutation").CopyGraphVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").CopyGraphPayloadSelect>) => import("../orm").QueryBuilder<{
+            copyGraph: import("../orm").InferSelectResult<import("../orm/input-types").CopyGraphPayload, S> | null;
+        }>;
+        saveGraph: <S extends import("../orm/input-types").SaveGraphPayloadSelect>(args: import("../orm/mutation").SaveGraphVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").SaveGraphPayloadSelect>) => import("../orm").QueryBuilder<{
+            saveGraph: import("../orm").InferSelectResult<import("../orm/input-types").SaveGraphPayload, S> | null;
+        }>;
+        addEdgeAndSave: <S extends import("../orm/input-types").AddEdgeAndSavePayloadSelect>(args: import("../orm/mutation").AddEdgeAndSaveVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").AddEdgeAndSavePayloadSelect>) => import("../orm").QueryBuilder<{
+            addEdgeAndSave: import("../orm").InferSelectResult<import("../orm/input-types").AddEdgeAndSavePayload, S> | null;
+        }>;
+        addNodeAndSave: <S extends import("../orm/input-types").AddNodeAndSavePayloadSelect>(args: import("../orm/mutation").AddNodeAndSaveVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").AddNodeAndSavePayloadSelect>) => import("../orm").QueryBuilder<{
+            addNodeAndSave: import("../orm").InferSelectResult<import("../orm/input-types").AddNodeAndSavePayload, S> | null;
+        }>;
+        addEdge: <S extends import("../orm/input-types").AddEdgePayloadSelect>(args: import("../orm/mutation").AddEdgeVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").AddEdgePayloadSelect>) => import("../orm").QueryBuilder<{
+            addEdge: import("../orm").InferSelectResult<import("../orm/input-types").AddEdgePayload, S> | null;
+        }>;
+        addNode: <S extends import("../orm/input-types").AddNodePayloadSelect>(args: import("../orm/mutation").AddNodeVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").AddNodePayloadSelect>) => import("../orm").QueryBuilder<{
+            addNode: import("../orm").InferSelectResult<import("../orm/input-types").AddNodePayload, S> | null;
+        }>;
+        importGraphJson: <S extends import("../orm/input-types").ImportGraphJsonPayloadSelect>(args: import("../orm/mutation").ImportGraphJsonVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").ImportGraphJsonPayloadSelect>) => import("../orm").QueryBuilder<{
+            importGraphJson: import("../orm").InferSelectResult<import("../orm/input-types").ImportGraphJsonPayload, S> | null;
+        }>;
+        insertNodeAtPath: <S extends import("../orm/input-types").InsertNodeAtPathPayloadSelect>(args: import("../orm/mutation").InsertNodeAtPathVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").InsertNodeAtPathPayloadSelect>) => import("../orm").QueryBuilder<{
+            insertNodeAtPath: import("../orm").InferSelectResult<import("../orm/input-types").InsertNodeAtPathPayload, S> | null;
+        }>;
+        startExecution: <S extends import("../orm/input-types").StartExecutionPayloadSelect>(args: import("../orm/mutation").StartExecutionVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").StartExecutionPayloadSelect>) => import("../orm").QueryBuilder<{
+            startExecution: import("../orm").InferSelectResult<import("../orm/input-types").StartExecutionPayload, S> | null;
+        }>;
+        provisionBucket: <S extends import("../orm/input-types").ProvisionBucketPayloadSelect>(args: import("../orm/mutation").ProvisionBucketVariables, options: {
+            select: S;
+        } & import("../orm").StrictSelect<S, import("../orm/input-types").ProvisionBucketPayloadSelect>) => import("../orm").QueryBuilder<{
+            provisionBucket: import("../orm").InferSelectResult<import("../orm/input-types").ProvisionBucketPayload, S> | null;
+        }>;
+    };
+};

package/compute/cli/executor.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStore = void 0;
+exports.getClient = getClient;
+/**
+ * Executor and config store for CLI
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const appstash_1 = require("appstash");
+const orm_1 = require("../orm");
+const store = (0, appstash_1.createConfigStore)('csdk');
+const getStore = () => store;
+exports.getStore = getStore;
+function getClient(contextName) {
+    let ctx = null;
+    if (contextName) {
+        ctx = store.loadContext(contextName);
+        if (!ctx) {
+            throw new Error(`Context "${contextName}" not found.`);
+        }
+    }
+    else {
+        ctx = store.getCurrentContext();
+        if (!ctx) {
+            throw new Error('No active context. Run "context create" or "context use" first.');
+        }
+    }
+    const headers = {};
+    if (store.hasValidCredentials(ctx.name)) {
+        const creds = store.getCredentials(ctx.name);
+        if (creds?.token) {
+            headers.Authorization = `Bearer ${creds.token}`;
+        }
+    }
+    return (0, orm_1.createClient)({
+        endpoint: ctx.endpoint,
+        headers: headers,
+    });
+}

package/compute/cli/index.d.ts

@@ -0,0 +1 @@
+export {};

package/compute/cli/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * CLI entry point
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const inquirerer_1 = require("inquirerer");
+const commands_1 = require("./commands");
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    const pkg = (0, inquirerer_1.getPackageJson)(__dirname);
+    console.log(pkg.version);
+    process.exit(0);
+}
+// Check for --tty false or --no-tty to enable non-interactive mode (noTty)
+const ttyIdx = process.argv.indexOf('--tty');
+const noTty = (ttyIdx !== -1 && process.argv[ttyIdx + 1] === 'false') || process.argv.includes('--no-tty');
+const options = {
+    noTty,
+    minimistOpts: { alias: { v: 'version', h: 'help' } },
+};
+const app = new inquirerer_1.CLI(commands_1.commands, options);
+app.run().catch((e) => {
+    console.error('Unexpected error:', e);
+    process.exit(1);
+});

package/compute/cli/utils.d.ts

@@ -0,0 +1,88 @@
+export type FieldType = 'string' | 'boolean' | 'int' | 'float' | 'json' | 'uuid' | 'enum';
+export interface FieldSchema {
+    [fieldName: string]: FieldType;
+}
+/**
+ * Coerce CLI string arguments to their proper GraphQL types based on a field schema.
+ * CLI args always arrive as strings from minimist, but GraphQL expects
+ * Boolean, Int, Float, JSON, etc.
+ */
+export declare function coerceAnswers(answers: Record<string, unknown>, schema: FieldSchema): Record<string, unknown>;
+/**
+ * Strip undefined values and filter to only schema-defined keys.
+ * This removes extra fields injected by minimist (like _, tty, etc.)
+ * and any fields that were coerced to undefined.
+ */
+export declare function stripUndefined(obj: Record<string, unknown>, schema?: FieldSchema): Record<string, unknown>;
+/**
+ * Parse mutation input from CLI.
+ * Custom mutation commands receive an `input` field as a JSON string
+ * from the CLI prompt. This parses it into a proper object.
+ */
+export declare function parseMutationInput(answers: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Reconstruct nested objects from dot-notation CLI answers.
+ * When INPUT_OBJECT args are flattened to dot-notation questions
+ * (e.g. `--input.email foo --input.password bar`), this function
+ * rebuilds the nested structure expected by the ORM:
+ *
+ *   { 'input.email': 'foo', 'input.password': 'bar' }
+ *   → { input: { email: 'foo', password: 'bar' } }
+ *
+ * Non-dotted keys are passed through unchanged.
+ * Uses `nested-obj` for safe nested property setting.
+ */
+export declare function unflattenDotNotation(answers: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build a select object from a comma-separated list of dot-notation paths.
+ * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'
+ * into the nested structure expected by the ORM:
+ *
+ *   { clientMutationId: true, result: { select: { accessToken: true, userId: true } } }
+ *
+ * Paths without dots set the key to `true` (scalar select).
+ * Paths with dots create nested `{ select: { ... } }` wrappers, matching the
+ * ORM's expected structure for OBJECT sub-fields (e.g. `SignUpPayloadSelect.result`).
+ *
+ * @param paths - Comma-separated dot-notation field paths (e.g. 'clientMutationId,result.accessToken')
+ * @returns The nested select object for the ORM
+ */
+/**
+ * Parse a CLI flag as an integer.
+ * Handles minimist delivering numbers or strings depending on the input.
+ * Returns undefined when the flag is missing or not a valid number.
+ */
+export declare function parseIntFlag(argv: Record<string, unknown>, name: string): number | undefined;
+/**
+ * Parse a CLI flag as a string.
+ * Returns undefined when the flag is missing or not a string.
+ */
+export declare function parseStringFlag(argv: Record<string, unknown>, name: string): string | undefined;
+/**
+ * Parse --orderBy flag as a comma-separated list of enum values.
+ * e.g. --orderBy NAME_ASC,CREATED_AT_DESC → ['NAME_ASC', 'CREATED_AT_DESC']
+ */
+export declare function parseOrderByFlag(argv: Record<string, unknown>): string[] | undefined;
+/**
+ * Parse --select flag into a select object, falling back to a default.
+ * e.g. --select id,name → { id: true, name: true }
+ */
+export declare function parseSelectFlag(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build the full findManyArgs object from CLI argv.
+ * Parses all pagination, filtering, ordering, and field selection flags
+ * in one call.  Accepts an optional `extraWhere` to merge with dot-notation
+ * --where flags (used by the search handler to inject search clauses).
+ *
+ * @example
+ *   const findManyArgs = parseFindManyArgs(argv, { id: true, name: true });
+ *   const result = await client.user.findMany(findManyArgs).execute();
+ */
+export declare function parseFindManyArgs<T = Record<string, unknown>>(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>, extraWhere?: Record<string, unknown>): T;
+/**
+ * Build findFirst args from CLI argv.
+ * Like parseFindManyArgs but without pagination flags (no limit/offset/after/before/last)
+ * — findFirst returns the first matching record. Supports select, where, and orderBy.
+ */
+export declare function parseFindFirstArgs<T = Record<string, unknown>>(argv: Record<string, unknown>, defaultSelect: Record<string, unknown>): T;
+export declare function buildSelectFromPaths(paths: string): Record<string, unknown>;

package/compute/cli/utils.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coerceAnswers = coerceAnswers;
+exports.stripUndefined = stripUndefined;
+exports.parseMutationInput = parseMutationInput;
+exports.unflattenDotNotation = unflattenDotNotation;
+exports.parseIntFlag = parseIntFlag;
+exports.parseStringFlag = parseStringFlag;
+exports.parseOrderByFlag = parseOrderByFlag;
+exports.parseSelectFlag = parseSelectFlag;
+exports.parseFindManyArgs = parseFindManyArgs;
+exports.parseFindFirstArgs = parseFindFirstArgs;
+exports.buildSelectFromPaths = buildSelectFromPaths;
+/**
+ * CLI utility functions for type coercion and input handling
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+const nested_obj_1 = __importDefault(require("nested-obj"));
+/**
+ * Coerce CLI string arguments to their proper GraphQL types based on a field schema.
+ * CLI args always arrive as strings from minimist, but GraphQL expects
+ * Boolean, Int, Float, JSON, etc.
+ */
+function coerceAnswers(answers, schema) {
+    const result = { ...answers };
+    for (const [key, value] of Object.entries(result)) {
+        const fieldType = schema[key];
+        if (!fieldType || value === undefined || value === null)
+            continue;
+        const strValue = String(value);
+        // Empty strings become undefined for non-string types
+        if (strValue === '' && fieldType !== 'string') {
+            result[key] = undefined;
+            continue;
+        }
+        switch (fieldType) {
+            case 'boolean':
+                if (typeof value === 'boolean')
+                    break;
+                result[key] = strValue === 'true' || strValue === '1' || strValue === 'yes';
+                break;
+            case 'int':
+                if (typeof value === 'number')
+                    break;
+                {
+                    const parsed = parseInt(strValue, 10);
+                    result[key] = isNaN(parsed) ? undefined : parsed;
+                }
+                break;
+            case 'float':
+                if (typeof value === 'number')
+                    break;
+                {
+                    const parsed = parseFloat(strValue);
+                    result[key] = isNaN(parsed) ? undefined : parsed;
+                }
+                break;
+            case 'json':
+                if (typeof value === 'object')
+                    break;
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                else {
+                    try {
+                        result[key] = JSON.parse(strValue);
+                    }
+                    catch {
+                        result[key] = undefined;
+                    }
+                }
+                break;
+            case 'uuid':
+                // Empty UUIDs become undefined
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+            case 'enum':
+                // Enums stay as strings but empty ones become undefined
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+            default:
+                // String type: empty strings also become undefined to avoid
+                // sending empty strings for optional fields
+                if (strValue === '') {
+                    result[key] = undefined;
+                }
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Strip undefined values and filter to only schema-defined keys.
+ * This removes extra fields injected by minimist (like _, tty, etc.)
+ * and any fields that were coerced to undefined.
+ */
+function stripUndefined(obj, schema) {
+    const result = {};
+    const allowedKeys = schema ? new Set(Object.keys(schema)) : null;
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined)
+            continue;
+        if (allowedKeys && !allowedKeys.has(key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Parse mutation input from CLI.
+ * Custom mutation commands receive an `input` field as a JSON string
+ * from the CLI prompt. This parses it into a proper object.
+ */
+function parseMutationInput(answers) {
+    if (typeof answers.input === 'string') {
+        try {
+            const parsed = JSON.parse(answers.input);
+            return { ...answers, input: parsed };
+        }
+        catch {
+            return answers;
+        }
+    }
+    return answers;
+}
+/**
+ * Reconstruct nested objects from dot-notation CLI answers.
+ * When INPUT_OBJECT args are flattened to dot-notation questions
+ * (e.g. `--input.email foo --input.password bar`), this function
+ * rebuilds the nested structure expected by the ORM:
+ *
+ *   { 'input.email': 'foo', 'input.password': 'bar' }
+ *   → { input: { email: 'foo', password: 'bar' } }
+ *
+ * Non-dotted keys are passed through unchanged.
+ * Uses `nested-obj` for safe nested property setting.
+ */
+function unflattenDotNotation(answers) {
+    const result = {};
+    for (const [key, value] of Object.entries(answers)) {
+        if (key.includes('.')) {
+            nested_obj_1.default.set(result, key, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Build a select object from a comma-separated list of dot-notation paths.
+ * Uses `nested-obj` to parse paths like 'clientMutationId,result.accessToken,result.userId'
+ * into the nested structure expected by the ORM:
+ *
+ *   { clientMutationId: true, result: { select: { accessToken: true, userId: true } } }
+ *
+ * Paths without dots set the key to `true` (scalar select).
+ * Paths with dots create nested `{ select: { ... } }` wrappers, matching the
+ * ORM's expected structure for OBJECT sub-fields (e.g. `SignUpPayloadSelect.result`).
+ *
+ * @param paths - Comma-separated dot-notation field paths (e.g. 'clientMutationId,result.accessToken')
+ * @returns The nested select object for the ORM
+ */
+/**
+ * Parse a CLI flag as an integer.
+ * Handles minimist delivering numbers or strings depending on the input.
+ * Returns undefined when the flag is missing or not a valid number.
+ */
+function parseIntFlag(argv, name) {
+    const val = argv[name];
+    if (typeof val === 'number')
+        return val;
+    if (typeof val === 'string') {
+        const n = parseInt(val, 10);
+        return isNaN(n) ? undefined : n;
+    }
+    return undefined;
+}
+/**
+ * Parse a CLI flag as a string.
+ * Returns undefined when the flag is missing or not a string.
+ */
+function parseStringFlag(argv, name) {
+    const val = argv[name];
+    return typeof val === 'string' ? val : undefined;
+}
+/**
+ * Parse --orderBy flag as a comma-separated list of enum values.
+ * e.g. --orderBy NAME_ASC,CREATED_AT_DESC → ['NAME_ASC', 'CREATED_AT_DESC']
+ */
+function parseOrderByFlag(argv) {
+    const val = argv.orderBy;
+    return typeof val === 'string' ? val.split(',') : undefined;
+}
+/**
+ * Parse --select flag into a select object, falling back to a default.
+ * e.g. --select id,name → { id: true, name: true }
+ */
+function parseSelectFlag(argv, defaultSelect) {
+    const raw = argv.select;
+    return typeof raw === 'string' ? buildSelectFromPaths(raw) : defaultSelect;
+}
+/**
+ * Build the full findManyArgs object from CLI argv.
+ * Parses all pagination, filtering, ordering, and field selection flags
+ * in one call.  Accepts an optional `extraWhere` to merge with dot-notation
+ * --where flags (used by the search handler to inject search clauses).
+ *
+ * @example
+ *   const findManyArgs = parseFindManyArgs(argv, { id: true, name: true });
+ *   const result = await client.user.findMany(findManyArgs).execute();
+ */
+function parseFindManyArgs(argv, defaultSelect, extraWhere) {
+    const limit = parseIntFlag(argv, 'limit');
+    const last = parseIntFlag(argv, 'last');
+    const offset = parseIntFlag(argv, 'offset');
+    const after = parseStringFlag(argv, 'after');
+    const before = parseStringFlag(argv, 'before');
+    const select = parseSelectFlag(argv, defaultSelect);
+    const parsed = unflattenDotNotation(argv);
+    const where = (parsed.where ?? extraWhere)
+        ? { ...(extraWhere ?? {}), ...(parsed.where ?? {}) }
+        : undefined;
+    const orderBy = parseOrderByFlag(argv);
+    return {
+        select,
+        ...(limit !== undefined ? { first: limit } : {}),
+        ...(after !== undefined ? { after } : {}),
+        ...(last !== undefined ? { last } : {}),
+        ...(before !== undefined ? { before } : {}),
+        ...(offset !== undefined ? { offset } : {}),
+        ...(where !== undefined ? { where } : {}),
+        ...(orderBy !== undefined ? { orderBy } : {}),
+    };
+}
+/**
+ * Build findFirst args from CLI argv.
+ * Like parseFindManyArgs but without pagination flags (no limit/offset/after/before/last)
+ * — findFirst returns the first matching record. Supports select, where, and orderBy.
+ */
+function parseFindFirstArgs(argv, defaultSelect) {
+    const select = parseSelectFlag(argv, defaultSelect);
+    const parsed = unflattenDotNotation(argv);
+    const where = parsed.where;
+    const orderBy = parseOrderByFlag(argv);
+    return {
+        select,
+        ...(where !== undefined ? { where } : {}),
+        ...(orderBy !== undefined ? { orderBy } : {}),
+    };
+}
+function buildSelectFromPaths(paths) {
+    const result = {};
+    const trimmedPaths = paths
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+    for (const path of trimmedPaths) {
+        if (!path.includes('.')) {
+            // Simple scalar field: clientMutationId -> { clientMutationId: true }
+            result[path] = true;
+        }
+        else {
+            // Nested path: result.accessToken -> { result: { select: { accessToken: true } } }
+            // Convert dot-notation to ORM's { select: { ... } } nesting pattern
+            const parts = path.split('.');
+            let current = result;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (i === parts.length - 1) {
+                    // Leaf node: set to true
+                    nested_obj_1.default.set(current, part, true);
+                }
+                else {
+                    // Intermediate node: ensure { select: { ... } } wrapper exists
+                    if (!current[part] || typeof current[part] !== 'object') {
+                        current[part] = { select: {} };
+                    }
+                    const wrapper = current[part];
+                    if (!wrapper.select || typeof wrapper.select !== 'object') {
+                        wrapper.select = {};
+                    }
+                    current = wrapper.select;
+                }
+            }
+        }
+    }
+    return result;
+}

package/compute/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+export * from './orm';
+export * from './cli';

package/compute/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * GraphQL SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+__exportStar(require("./orm"), exports);
+__exportStar(require("./cli"), exports);