@xano/cli 0.0.95-beta.12 → 0.0.95-beta.13

package/dist/commands/sandbox/push/index.d.ts

@@ -15,5 +15,6 @@ export default class SandboxPush extends BaseCommand {
     };
     run(): Promise<void>;
     private collectFiles;
+    private renderBadIndexes;
     private renderBadReferences;
 }

package/dist/commands/sandbox/push/index.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import BaseCommand from '../../../base-command.js';
 import { findFilesWithGuid } from '../../../utils/document-parser.js';
-import { checkReferences } from '../../../utils/reference-checker.js';
+import { checkReferences, checkTableIndexes } from '../../../utils/reference-checker.js';
 export default class SandboxPush extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -72,6 +72,11 @@ Pushed 42 documents to sandbox environment from ./my-workspace
         if (badRefs.length > 0) {
             this.renderBadReferences(badRefs);
         }
+        // Check for indexes referencing non-existent schema fields
+        const badIndexes = checkTableIndexes(documentEntries);
+        if (badIndexes.length > 0) {
+            this.renderBadIndexes(badIndexes);
+        }
         const multidoc = documentEntries.map((d) => d.content).join('\n---\n');
         const queryParams = new URLSearchParams({
             env: flags.env.toString(),
@@ -150,6 +155,19 @@ Pushed 42 documents to sandbox environment from ./my-workspace
         }
         return files.sort();
     }
+    renderBadIndexes(badIndexes) {
+        this.log('');
+        this.log(ux.colorize('red', ux.colorize('bold', '=== CRITICAL: Invalid Indexes ===')));
+        this.log('');
+        this.log(ux.colorize('red', 'The following tables have indexes referencing fields that do not exist in the schema.'));
+        this.log(ux.colorize('red', 'These will cause the import to fail.'));
+        this.log('');
+        for (const idx of badIndexes) {
+            this.log(`  ${ux.colorize('red', 'CRITICAL'.padEnd(16))} ${'table'.padEnd(18)} ${idx.table}`);
+            this.log(`  ${' '.repeat(16)} ${' '.repeat(18)} ${ux.colorize('dim', `${idx.indexType} index → field "${idx.field}" does not exist in schema`)}`);
+        }
+        this.log('');
+    }
     renderBadReferences(badRefs) {
         this.log('');
         this.log(ux.colorize('yellow', ux.colorize('bold', '=== Unresolved References ===')));

package/dist/commands/workspace/push/index.d.ts

@@ -30,6 +30,7 @@ export default class Push extends BaseCommand {
      * type subdirectory name then filename for deterministic ordering.
      */
     private collectFiles;
+    private renderBadIndexes;
     private renderBadReferences;
     private loadCredentials;
 }

package/dist/commands/workspace/push/index.js

@@ -6,7 +6,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import BaseCommand from '../../../base-command.js';
 import { buildDocumentKey, findFilesWithGuid, parseDocument } from '../../../utils/document-parser.js';
-import { checkReferences } from '../../../utils/reference-checker.js';
+import { checkReferences, checkTableIndexes } from '../../../utils/reference-checker.js';
 export default class Push extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -331,6 +331,11 @@ Push functions but exclude test files
                         if (badRefs.length > 0) {
                             this.renderBadReferences(badRefs);
                         }
+                        // Check for indexes referencing non-existent schema fields
+                        const badIndexes = checkTableIndexes(documentEntries);
+                        if (badIndexes.length > 0) {
+                            this.renderBadIndexes(badIndexes);
+                        }
                         // Check for critical errors that must block the push
                         const criticalOps = preview.operations.filter((op) => op.details?.includes('exception:') || op.details?.includes('mvp:placeholder'));
                         if (criticalOps.length > 0) {
@@ -751,6 +756,19 @@ Push functions but exclude test files
         }
         return files.sort();
     }
+    renderBadIndexes(badIndexes) {
+        this.log('');
+        this.log(ux.colorize('red', ux.colorize('bold', '=== CRITICAL: Invalid Indexes ===')));
+        this.log('');
+        this.log(ux.colorize('red', 'The following tables have indexes referencing fields that do not exist in the schema.'));
+        this.log(ux.colorize('red', 'These will cause the import to fail.'));
+        this.log('');
+        for (const idx of badIndexes) {
+            this.log(`  ${ux.colorize('red', 'CRITICAL'.padEnd(16))} ${'table'.padEnd(18)} ${idx.table}`);
+            this.log(`  ${' '.repeat(16)} ${' '.repeat(18)} ${ux.colorize('dim', `${idx.indexType} index → field "${idx.field}" does not exist in schema`)}`);
+        }
+        this.log('');
+    }
     renderBadReferences(badRefs) {
         this.log(ux.colorize('yellow', ux.colorize('bold', '=== Unresolved References ===')));
         this.log('');

package/dist/utils/reference-checker.d.ts

@@ -43,3 +43,15 @@ export declare function checkReferences(documents: Array<{
     name: string;
     type: string;
 }>): BadReference[];
+export interface BadIndex {
+    field: string;
+    indexType: string;
+    table: string;
+}
+/**
+ * Check table documents for indexes that reference fields not in the schema.
+ * Parses the XanoScript table format to extract schema field names and index field names.
+ */
+export declare function checkTableIndexes(documents: Array<{
+    content: string;
+}>): BadIndex[];

package/dist/utils/reference-checker.js

@@ -143,3 +143,90 @@ export function checkReferences(documents, serverOperations) {
     }
     return badRefs;
 }
+/**
+ * Check table documents for indexes that reference fields not in the schema.
+ * Parses the XanoScript table format to extract schema field names and index field names.
+ */
+export function checkTableIndexes(documents) {
+    const badIndexes = [];
+    for (const doc of documents) {
+        const parsed = parseDocument(doc.content);
+        if (!parsed || parsed.type !== 'table')
+            continue;
+        const schemaFields = extractSchemaFields(doc.content);
+        const indexes = extractIndexes(doc.content);
+        for (const idx of indexes) {
+            for (const field of idx.fields) {
+                if (!schemaFields.has(field)) {
+                    badIndexes.push({
+                        field,
+                        indexType: idx.type,
+                        table: parsed.name,
+                    });
+                }
+            }
+        }
+    }
+    return badIndexes;
+}
+function extractSchemaFields(content) {
+    // id and created_at are auto-added during import
+    const fields = new Set(['id', 'created_at']);
+    // Find the schema block by matching braces
+    const schemaStart = content.match(/\bschema\s*\{/);
+    if (!schemaStart || schemaStart.index === undefined)
+        return fields;
+    let depth = 0;
+    let blockStart = -1;
+    let blockEnd = -1;
+    for (let i = schemaStart.index; i < content.length; i++) {
+        if (content[i] === '{') {
+            if (depth === 0)
+                blockStart = i + 1;
+            depth++;
+        }
+        else if (content[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                blockEnd = i;
+                break;
+            }
+        }
+    }
+    if (blockStart < 0 || blockEnd < 0)
+        return fields;
+    const schemaBlock = content.slice(blockStart, blockEnd);
+    // Match field declarations: "type name" or "type name?" or "type name?=default"
+    const fieldRegex = /^\s*\w+\s+(\w+)[?\s{]/gm;
+    let match;
+    while ((match = fieldRegex.exec(schemaBlock)) !== null) {
+        fields.add(match[1]);
+    }
+    return fields;
+}
+function extractIndexes(content) {
+    const indexes = [];
+    // Match the index array: index = [ ... ]
+    const indexMatch = content.match(/\bindex\s*=\s*\[([\s\S]*?)\n\s*\]/);
+    if (!indexMatch)
+        return indexes;
+    const indexBlock = indexMatch[1];
+    // Match each index object: {type: "btree", field: [{name: "col", op: "desc"}]}
+    const entryRegex = /\{([^}]+)\}/g;
+    let match;
+    while ((match = entryRegex.exec(indexBlock)) !== null) {
+        const entry = match[1];
+        const typeMatch = entry.match(/type:\s*"(\w+)"/);
+        const type = typeMatch ? typeMatch[1] : 'unknown';
+        const fieldNames = [];
+        const nameRegex = /name:\s*"(\w*)"/g;
+        let nameMatch;
+        while ((nameMatch = nameRegex.exec(entry)) !== null) {
+            fieldNames.push(nameMatch[1]);
+        }
+        if (fieldNames.length > 0) {
+            indexes.push({ fields: fieldNames, type });
+        }
+    }
+    return indexes;
+}