@xano/cli 0.0.40 → 0.0.42

package/README.md

@@ -106,9 +106,12 @@ xano workspace pull ./my-workspace --draft              # Include draft changes
 # Push local files to workspace
 xano workspace push ./my-workspace
 xano workspace push ./my-workspace -b dev
-xano workspace push ./my-workspace --no-records         # Schema only
-xano workspace push ./my-workspace --no-env             # Skip env vars
-xano workspace push ./my-workspace --truncate           # Truncate tables before import
+xano workspace push ./my-workspace --partial             # No workspace block required
+xano workspace push ./my-workspace --delete              # Delete objects not in the push
+xano workspace push ./my-workspace --no-records          # Schema only
+xano workspace push ./my-workspace --no-env              # Skip env vars
+xano workspace push ./my-workspace --truncate            # Truncate tables before import
+xano workspace push ./my-workspace --no-sync-guids       # Skip writing GUIDs back to local files
 ```
 
 ### Branches

package/dist/commands/profile/me/index.js

@@ -62,8 +62,8 @@ User Information:
         try {
             const response = await this.verboseFetch(apiUrl, {
                 headers: {
-                    'accept': 'application/json',
-                    'Authorization': `Bearer ${profile.access_token}`,
+                    accept: 'application/json',
+                    Authorization: `Bearer ${profile.access_token}`,
                 },
                 method: 'GET',
             }, flags.verbose, profile.access_token);
@@ -71,7 +71,7 @@ User Information:
                 const errorText = await response.text();
                 this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
             }
-            const data = await response.json();
+            const data = (await response.json());
             // Output results
             if (flags.output === 'json') {
                 this.log(JSON.stringify(data, null, 2));
@@ -92,17 +92,37 @@ User Information:
                     const date = new Date(data.created_at * 1000);
                     this.log(`  Created: ${date.toISOString()}`);
                 }
-                // Display any other fields that aren't already shown
+                // Display extra fields from the API response
                 const knownFields = new Set(['created_at', 'email', 'id', 'name']);
-                for (const [key, value] of Object.entries(data)) {
-                    if (!knownFields.has(key) && value !== null && value !== undefined) {
-                        if (typeof value === 'object') {
-                            this.log(`  ${this.formatKey(key)}: ${JSON.stringify(value)}`);
-                        }
-                        else {
-                            this.log(`  ${this.formatKey(key)}: ${value}`);
+                // In default mode, show condensed instance info from extras
+                // In verbose mode, show all extra fields with full detail
+                const extras = data.extras;
+                if (extras?.instance && typeof extras.instance === 'object') {
+                    const inst = extras.instance;
+                    this.log('');
+                    this.log('Instance Information:');
+                    if (inst.id)
+                        this.log(`  ID: ${inst.id}`);
+                    if (inst.name)
+                        this.log(`  Name: ${inst.name}`);
+                    if (inst.display)
+                        this.log(`  Display: ${inst.display}`);
+                }
+                if (flags.verbose) {
+                    knownFields.add('extras');
+                    for (const [key, value] of Object.entries(data)) {
+                        if (!knownFields.has(key) && value !== null && value !== undefined) {
+                            if (typeof value === 'object') {
+                                this.log(`  ${this.formatKey(key)}: ${JSON.stringify(value, null, 2)}`);
+                            }
+                            else {
+                                this.log(`  ${this.formatKey(key)}: ${value}`);
+                            }
                         }
                     }
+                    if (extras) {
+                        this.log(`  Extras: ${JSON.stringify(extras, null, 2)}`);
+                    }
                 }
             }
         }
@@ -119,7 +139,7 @@ User Information:
         // Convert snake_case to Title Case
         return key
             .split('_')
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
             .join(' ');
     }
     loadCredentials() {
@@ -127,8 +147,7 @@ User Information:
         const credentialsPath = path.join(configDir, 'credentials.yaml');
         // Check if credentials file exists
         if (!fs.existsSync(credentialsPath)) {
-            this.error(`Credentials file not found at ${credentialsPath}\n` +
-                `Create a profile using 'xano profile:create'`);
+            this.error(`Credentials file not found at ${credentialsPath}\n` + `Create a profile using 'xano profile:create'`);
         }
         // Read credentials file
         try {

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

@@ -16,12 +16,6 @@ export default class Pull extends BaseCommand {
     };
     run(): Promise<void>;
     private loadCredentials;
-    /**
-     * Parse a single document to extract its type, name, and optional verb.
-     * Skips leading comment lines (starting with //) to find the first
-     * meaningful line containing the type keyword and name.
-     */
-    private parseDocument;
     /**
      * Sanitize a document name for use as a filename.
      * Strips quotes, replaces spaces with underscores, and removes

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

@@ -5,6 +5,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
+import { parseDocument } from '../../../utils/document-parser.js';
 export default class Pull extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -104,8 +105,8 @@ Pulled 42 documents to ./my-workspace
         // Fetch multidoc from the API
         let responseText;
         const requestHeaders = {
-            'accept': 'application/json',
-            'Authorization': `Bearer ${profile.access_token}`,
+            accept: 'application/json',
+            Authorization: `Bearer ${profile.access_token}`,
         };
         try {
             const response = await this.verboseFetch(apiUrl, {
@@ -135,7 +136,7 @@ Pulled 42 documents to ./my-workspace
             if (!trimmed) {
                 continue;
             }
-            const parsed = this.parseDocument(trimmed);
+            const parsed = parseDocument(trimmed);
             if (parsed) {
                 documents.push(parsed);
             }
@@ -256,8 +257,7 @@ Pulled 42 documents to ./my-workspace
         const credentialsPath = path.join(configDir, 'credentials.yaml');
         // Check if credentials file exists
         if (!fs.existsSync(credentialsPath)) {
-            this.error(`Credentials file not found at ${credentialsPath}\n` +
-                `Create a profile using 'xano profile:create'`);
+            this.error(`Credentials file not found at ${credentialsPath}\n` + `Create a profile using 'xano profile:create'`);
         }
         // Read credentials file
         try {
@@ -272,56 +272,6 @@ Pulled 42 documents to ./my-workspace
             this.error(`Failed to parse credentials file: ${error}`);
         }
     }
-    /**
-     * Parse a single document to extract its type, name, and optional verb.
-     * Skips leading comment lines (starting with //) to find the first
-     * meaningful line containing the type keyword and name.
-     */
-    parseDocument(content) {
-        const lines = content.split('\n');
-        // Find the first non-comment line
-        let firstLine = null;
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine && !trimmedLine.startsWith('//')) {
-                firstLine = trimmedLine;
-                break;
-            }
-        }
-        if (!firstLine) {
-            return null;
-        }
-        // Parse the type keyword and name from the first meaningful line
-        // Expected formats:
-        //   type name {
-        //   type name verb=GET {
-        //   type "name with spaces" {
-        //   type "name with spaces" verb=PATCH {
-        const match = firstLine.match(/^(\w+)\s+("(?:[^"\\]|\\.)*"|\S+)(?:\s+(.*))?/);
-        if (!match) {
-            return null;
-        }
-        const type = match[1];
-        let name = match[2];
-        const rest = match[3] || '';
-        // Strip surrounding quotes from the name
-        if (name.startsWith('"') && name.endsWith('"')) {
-            name = name.slice(1, -1);
-        }
-        // Extract verb if present (e.g., verb=GET)
-        let verb;
-        const verbMatch = rest.match(/verb=(\S+)/);
-        if (verbMatch) {
-            verb = verbMatch[1];
-        }
-        // Extract api_group if present (e.g., api_group = "test")
-        let apiGroup;
-        const apiGroupMatch = content.match(/api_group\s*=\s*"([^"]*)"/);
-        if (apiGroupMatch) {
-            apiGroup = apiGroupMatch[1];
-        }
-        return { apiGroup, content, name, type, verb };
-    }
     /**
      * Sanitize a document name for use as a filename.
      * Strips quotes, replaces spaces with underscores, and removes

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

@@ -7,8 +7,11 @@ export default class Push extends BaseCommand {
     static examples: string[];
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        delete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        partial: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         records: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'sync-guids': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         truncate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

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

@@ -4,6 +4,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import BaseCommand from '../../../base-command.js';
+import { buildDocumentKey, parseDocument } from '../../../utils/document-parser.js';
 export default class Push extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -24,6 +25,12 @@ Pushed 58 documents from ./backup
 `,
         `$ xano workspace push ./my-workspace -b dev
 Pushed 42 documents from ./my-workspace
+`,
+        `$ xano workspace push ./my-functions --partial
+Push some files without a workspace block (implies --no-delete)
+`,
+        `$ xano workspace push ./my-workspace --no-delete
+Patch files without deleting existing workspace objects
 `,
         `$ xano workspace push ./my-workspace --no-records
 Push schema only, skip importing table records
@@ -48,18 +55,35 @@ Push schema only, skip records and environment variables
             description: 'Branch name (optional if set in profile, defaults to live)',
             required: false,
         }),
+        delete: Flags.boolean({
+            allowNo: true,
+            default: false,
+            description: 'Delete workspace objects not included in the push (default: false)',
+            required: false,
+        }),
         env: Flags.boolean({
             allowNo: true,
             default: true,
             description: 'Include environment variables in import (default: true, use --no-env to exclude)',
             required: false,
         }),
+        partial: Flags.boolean({
+            default: false,
+            description: 'Partial push — workspace block is not required, existing objects are kept (implies --no-delete)',
+            required: false,
+        }),
         records: Flags.boolean({
             allowNo: true,
             default: true,
             description: 'Include records in import (default: true, use --no-records to exclude)',
             required: false,
         }),
+        'sync-guids': Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Write server-assigned GUIDs back to local files (use --no-sync-guids to skip)',
+            required: false,
+        }),
         truncate: Flags.boolean({
             default: false,
             description: 'Truncate all table records before importing',
@@ -116,24 +140,37 @@ Push schema only, skip records and environment variables
         if (files.length === 0) {
             this.error(`No .xs files found in ${args.directory}`);
         }
-        // Read each file and join with --- separator
-        const documents = [];
+        // Read each file and track file path alongside content
+        const documentEntries = [];
         for (const filePath of files) {
             const content = fs.readFileSync(filePath, 'utf8').trim();
             if (content) {
-                documents.push(content);
+                documentEntries.push({ content, filePath });
             }
         }
-        if (documents.length === 0) {
+        if (documentEntries.length === 0) {
             this.error(`All .xs files in ${args.directory} are empty`);
         }
-        const multidoc = documents.join('\n---\n');
+        const multidoc = documentEntries.map((d) => d.content).join('\n---\n');
+        // Build lookup map from document key to file path (for GUID writeback)
+        const documentFileMap = new Map();
+        for (const entry of documentEntries) {
+            const parsed = parseDocument(entry.content);
+            if (parsed) {
+                const key = buildDocumentKey(parsed.type, parsed.name, parsed.verb, parsed.apiGroup);
+                documentFileMap.set(key, entry.filePath);
+            }
+        }
         // Determine branch from flag or profile
         const branch = flags.branch || profile.branch || '';
+        // --partial implies --no-delete
+        const shouldDelete = flags.partial ? false : flags.delete;
         // Construct the API URL
         const queryParams = new URLSearchParams({
             branch,
+            delete: shouldDelete.toString(),
             env: flags.env.toString(),
+            partial: flags.partial.toString(),
             records: flags.records.toString(),
             truncate: flags.truncate.toString(),
         });
@@ -165,10 +202,70 @@ Push schema only, skip records and environment variables
                 }
                 this.error(errorMessage);
             }
-            // Log the response if any
+            // Parse the response for GUID map
             const responseText = await response.text();
+            let guidMap = [];
             if (responseText && responseText !== 'null') {
-                this.log(responseText);
+                try {
+                    const responseJson = JSON.parse(responseText);
+                    if (responseJson?.guid_map && Array.isArray(responseJson.guid_map)) {
+                        guidMap = responseJson.guid_map;
+                    }
+                }
+                catch {
+                    // Response is not JSON (e.g., older server version)
+                    if (flags.verbose) {
+                        this.log('Server response is not JSON; skipping GUID sync');
+                    }
+                }
+            }
+            // Write GUIDs back to local files
+            if (flags['sync-guids'] && guidMap.length > 0) {
+                // Build a secondary lookup by type:name only (without verb/api_group)
+                // for cases where the server omits those fields
+                const baseKeyMap = new Map();
+                for (const [key, fp] of documentFileMap) {
+                    const baseKey = key.split(':').slice(0, 2).join(':');
+                    // Only use base key if there's no ambiguity (single entry per base key)
+                    if (baseKeyMap.has(baseKey)) {
+                        baseKeyMap.set(baseKey, ''); // Mark as ambiguous
+                    }
+                    else {
+                        baseKeyMap.set(baseKey, fp);
+                    }
+                }
+                let updatedCount = 0;
+                for (const entry of guidMap) {
+                    if (!entry.guid)
+                        continue;
+                    const key = buildDocumentKey(entry.type, entry.name, entry.verb, entry.api_group);
+                    let filePath = documentFileMap.get(key);
+                    // Fallback: try type:name only if full key didn't match
+                    if (!filePath) {
+                        const baseKey = `${entry.type}:${entry.name}`;
+                        const basePath = baseKeyMap.get(baseKey);
+                        if (basePath) {
+                            filePath = basePath;
+                        }
+                    }
+                    if (!filePath) {
+                        if (flags.verbose) {
+                            this.log(`  No local file found for ${entry.type} "${entry.name}", skipping GUID sync`);
+                        }
+                        continue;
+                    }
+                    try {
+                        const updated = syncGuidToFile(filePath, entry.guid);
+                        if (updated)
+                            updatedCount++;
+                    }
+                    catch (error) {
+                        this.warn(`Failed to sync GUID to ${filePath}: ${error.message}`);
+                    }
+                }
+                if (updatedCount > 0) {
+                    this.log(`Synced ${updatedCount} GUIDs to local files`);
+                }
             }
         }
         catch (error) {
@@ -179,7 +276,7 @@ Push schema only, skip records and environment variables
                 this.error(`Failed to push multidoc: ${String(error)}`);
             }
         }
-        this.log(`Pushed ${documents.length} documents from ${args.directory}`);
+        this.log(`Pushed ${documentEntries.length} documents from ${args.directory}`);
     }
     /**
      * Recursively collect all .xs files from a directory, sorted by
@@ -220,3 +317,52 @@ Push schema only, skip records and environment variables
         }
     }
 }
+const GUID_REGEX = /guid\s*=\s*(["'])([^"']*)\1/;
+/**
+ * Sync a GUID into a local .xs file. Returns true if the file was modified.
+ *
+ * - If the file already has a matching GUID, returns false (no change).
+ * - If the file has a different GUID, updates it.
+ * - If the file has no GUID, inserts one before the final closing brace.
+ */
+function syncGuidToFile(filePath, guid) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const existingMatch = content.match(GUID_REGEX);
+    if (existingMatch) {
+        // Already has a GUID
+        if (existingMatch[2] === guid) {
+            return false; // Already matches
+        }
+        // Update existing GUID
+        const updated = content.replace(GUID_REGEX, `guid = "${guid}"`);
+        fs.writeFileSync(filePath, updated, 'utf8');
+        return true;
+    }
+    // No GUID line exists — insert before the final closing brace of the top-level block
+    const lines = content.split('\n');
+    let insertIndex = -1;
+    // Find the last closing brace (top-level block end)
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (lines[i].trim() === '}') {
+            insertIndex = i;
+            break;
+        }
+    }
+    if (insertIndex === -1) {
+        return false; // Could not find insertion point
+    }
+    // Determine indentation from the line above the closing brace
+    let indent = '  ';
+    for (let i = insertIndex - 1; i >= 0; i--) {
+        if (lines[i].trim()) {
+            const indentMatch = lines[i].match(/^(\s+)/);
+            if (indentMatch) {
+                indent = indentMatch[1];
+            }
+            break;
+        }
+    }
+    lines.splice(insertIndex, 0, `${indent}guid = "${guid}"`);
+    fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
+    return true;
+}

package/dist/utils/document-parser.d.ts

@@ -0,0 +1,17 @@
+export interface ParsedDocument {
+    apiGroup?: string;
+    content: string;
+    name: string;
+    type: string;
+    verb?: string;
+}
+/**
+ * Parse a single XanoScript document to extract its type, name, and optional verb/api_group.
+ * Skips leading comment lines (starting with //) to find the first meaningful line.
+ */
+export declare function parseDocument(content: string): null | ParsedDocument;
+/**
+ * Build a unique key for a document based on its type, name, verb, and api_group.
+ * Used to match server GUID map entries back to local files.
+ */
+export declare function buildDocumentKey(type: string, name: string, verb?: string, apiGroup?: string): string;

package/dist/utils/document-parser.js

@@ -0,0 +1,61 @@
+/**
+ * Parse a single XanoScript document to extract its type, name, and optional verb/api_group.
+ * Skips leading comment lines (starting with //) to find the first meaningful line.
+ */
+export function parseDocument(content) {
+    const lines = content.split('\n');
+    // Find the first non-comment line
+    let firstLine = null;
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine && !trimmedLine.startsWith('//')) {
+            firstLine = trimmedLine;
+            break;
+        }
+    }
+    if (!firstLine) {
+        return null;
+    }
+    // Parse the type keyword and name from the first meaningful line
+    // Expected formats:
+    //   type name {
+    //   type name verb=GET {
+    //   type "name with spaces" {
+    //   type "name with spaces" verb=PATCH {
+    const match = firstLine.match(/^(\w+)\s+("(?:[^"\\]|\\.)*"|\S+)(?:\s+(.*))?/);
+    if (!match) {
+        return null;
+    }
+    const type = match[1];
+    let name = match[2];
+    const rest = match[3] || '';
+    // Strip surrounding quotes from the name
+    if (name.startsWith('"') && name.endsWith('"')) {
+        name = name.slice(1, -1);
+    }
+    // Extract verb if present (e.g., verb=GET)
+    let verb;
+    const verbMatch = rest.match(/verb=(\S+)/);
+    if (verbMatch) {
+        verb = verbMatch[1];
+    }
+    // Extract api_group if present (e.g., api_group = "test")
+    let apiGroup;
+    const apiGroupMatch = content.match(/api_group\s*=\s*"([^"]*)"/);
+    if (apiGroupMatch) {
+        apiGroup = apiGroupMatch[1];
+    }
+    return { apiGroup, content, name, type, verb };
+}
+/**
+ * Build a unique key for a document based on its type, name, verb, and api_group.
+ * Used to match server GUID map entries back to local files.
+ */
+export function buildDocumentKey(type, name, verb, apiGroup) {
+    const parts = [type, name];
+    if (verb)
+        parts.push(verb);
+    if (apiGroup)
+        parts.push(apiGroup);
+    return parts.join(':');
+}