@xano/cli 0.0.95 → 1.0.0

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

@@ -0,0 +1,57 @@
+/**
+ * A reference from one document to another (e.g., function.run "bad" references function "bad").
+ */
+export interface BadReference {
+    /** Name of the source document containing the reference */
+    source: string;
+    /** Type of the source document (e.g., "function") */
+    sourceType: string;
+    /** The statement type that creates the reference (e.g., "function.run") */
+    statementType: string;
+    /** The referenced name that doesn't exist */
+    target: string;
+    /** The target type being referenced (e.g., "function") */
+    targetType: string;
+}
+/**
+ * Build a registry of all defined object names from parsed documents.
+ * Returns a Map of type → Set of names.
+ */
+export declare function buildRegistry(documents: Array<{
+    content: string;
+}>): Map<string, Set<string>>;
+/**
+ * Build a registry of server-known object names from dry-run operations.
+ * Any object that appears in the dry-run (create, update, unchanged, delete) exists
+ * either locally or on the server.
+ */
+export declare function buildServerRegistry(operations: Array<{
+    name: string;
+    type: string;
+}>): Map<string, Set<string>>;
+/**
+ * Check all documents for cross-references that point to names not in the registry.
+ *
+ * When serverOperations is provided (from dry-run), references are checked against
+ * both local files AND server-known objects, eliminating false positives for objects
+ * that exist on the server but aren't in the push set.
+ */
+export declare function checkReferences(documents: Array<{
+    content: string;
+    filePath: string;
+}>, serverOperations?: 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

@@ -0,0 +1,232 @@
+import { parseDocument } from './document-parser.js';
+/**
+ * All known cross-reference patterns in XanoScript.
+ *
+ * Each pattern matches a statement keyword followed by a quoted or unquoted name.
+ * The first capture group extracts the name (stripping quotes if present).
+ */
+const REFERENCE_PATTERNS = [
+    { keyword: 'function.run', regex: /^\s*function\.run\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'function' },
+    { keyword: 'function.call', regex: /^\s*function\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'function' },
+    { keyword: 'addon.call', regex: /^\s*addon\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'addon' },
+    { keyword: 'task.call', regex: /^\s*task\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'task' },
+    { keyword: 'tool.call', regex: /^\s*tool\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'tool' },
+    { keyword: 'middleware.call', regex: /^\s*middleware\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'middleware' },
+    { keyword: 'ai.agent.run', regex: /^\s*ai\.agent\.run\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'agent' },
+    { keyword: 'trigger.call', regex: /^\s*trigger\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'trigger' },
+    { keyword: 'action.call', regex: /^\s*action\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm, targetType: 'action' },
+    {
+        keyword: 'workflow_test.call',
+        regex: /^\s*workflow_test\.call\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm,
+        targetType: 'workflow_test',
+    },
+    // db.* statements reference tables: db.get, db.query, db.add, db.edit, db.add_or_edit, db.delete, db.bulk_add, db.bulk_delete, db.count
+    {
+        keyword: 'db.*',
+        regex: /^\s*db\.(?:get|query|add|edit|add_or_edit|delete|bulk_add|bulk_delete|count)\s+("(?:[^"\\]|\\.)*"|[^\s{]+)/gm,
+        targetType: 'table',
+    },
+    // Schema foreign key references: table = "name" inside field definitions
+    { keyword: 'table (FK)', regex: /\btable\s*=\s*"([^"]*)"/gm, targetType: 'table' },
+];
+/**
+ * Strip surrounding quotes from a name if present.
+ */
+function stripQuotes(name) {
+    if (name.startsWith('"') && name.endsWith('"')) {
+        return name.slice(1, -1);
+    }
+    return name;
+}
+/**
+ * Map from XanoScript document types to the canonical type used in the registry.
+ * Some types are aliases (agent, mcp_server → toolset bucket, but referenced as "agent").
+ */
+/* eslint-disable camelcase */
+const TYPE_ALIASES = {
+    agent: 'agent',
+    mcp_server: 'agent',
+    toolset: 'agent',
+};
+/* eslint-enable camelcase */
+/**
+ * Normalize a document type to its canonical registry type.
+ */
+function normalizeType(type) {
+    return TYPE_ALIASES[type] ?? type;
+}
+/**
+ * Build a registry of all defined object names from parsed documents.
+ * Returns a Map of type → Set of names.
+ */
+export function buildRegistry(documents) {
+    const registry = new Map();
+    for (const doc of documents) {
+        const parsed = parseDocument(doc.content);
+        if (!parsed)
+            continue;
+        const type = normalizeType(parsed.type);
+        if (!registry.has(type)) {
+            registry.set(type, new Set());
+        }
+        registry.get(type).add(parsed.name);
+    }
+    return registry;
+}
+/**
+ * Build a registry of server-known object names from dry-run operations.
+ * Any object that appears in the dry-run (create, update, unchanged, delete) exists
+ * either locally or on the server.
+ */
+export function buildServerRegistry(operations) {
+    const registry = new Map();
+    for (const op of operations) {
+        const type = normalizeType(op.type);
+        if (!registry.has(type)) {
+            registry.set(type, new Set());
+        }
+        // Operation names for queries include the verb (e.g., "path/{id} DELETE")
+        // but references use just the name, so strip the verb suffix
+        const name = op.name.replace(/\s+(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$/, '');
+        registry.get(type).add(name);
+    }
+    return registry;
+}
+/**
+ * Check all documents for cross-references that point to names not in the registry.
+ *
+ * When serverOperations is provided (from dry-run), references are checked against
+ * both local files AND server-known objects, eliminating false positives for objects
+ * that exist on the server but aren't in the push set.
+ */
+export function checkReferences(documents, serverOperations) {
+    const registry = buildRegistry(documents);
+    // Merge server-known names into the registry
+    if (serverOperations) {
+        const serverRegistry = buildServerRegistry(serverOperations);
+        for (const [type, names] of serverRegistry) {
+            if (!registry.has(type)) {
+                registry.set(type, new Set());
+            }
+            for (const name of names) {
+                registry.get(type).add(name);
+            }
+        }
+    }
+    const badRefs = [];
+    for (const doc of documents) {
+        const parsed = parseDocument(doc.content);
+        if (!parsed)
+            continue;
+        for (const pattern of REFERENCE_PATTERNS) {
+            // Reset regex state for each document
+            pattern.regex.lastIndex = 0;
+            let match;
+            while ((match = pattern.regex.exec(doc.content)) !== null) {
+                const rawName = stripQuotes(match[1]);
+                // Skip empty names only for action.call (valid for integration actions)
+                if (!rawName && pattern.keyword === 'action.call')
+                    continue;
+                const { targetType } = pattern;
+                const knownNames = registry.get(targetType);
+                if (!knownNames || !knownNames.has(rawName)) {
+                    badRefs.push({
+                        source: parsed.name,
+                        sourceType: parsed.type,
+                        statementType: pattern.keyword,
+                        target: rawName,
+                        targetType,
+                    });
+                }
+            }
+        }
+    }
+    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;
+}