@xano/cli 0.0.64 → 0.0.66

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

@@ -5,7 +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';
+import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
 export default class Pull extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -149,6 +149,9 @@ Pulled 42 documents to ./my-workspace
         const outputDir = path.resolve(args.directory);
         // Create the output directory if it doesn't exist
         fs.mkdirSync(outputDir, { recursive: true });
+        // Resolve api_group names to unique folder names, disambiguating collisions
+        // where different names produce the same snakeCase (e.g., "Authentication" vs "authentication")
+        const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
         // Track filenames per type to handle duplicates
         const filenameCounters = new Map();
         let writtenCount = 0;
@@ -206,14 +209,14 @@ Pulled 42 documents to ./my-workspace
                 baseName = this.sanitizeFilename(doc.name);
             }
             else if (doc.type === 'api_group') {
-                // api_group "test" → api/test/api_group.xs
-                const groupFolder = snakeCase(doc.name);
+                // api_group "test" → api/{resolved_folder}/{name}.xs
+                const groupFolder = getApiGroupFolder(doc.name);
                 typeDir = path.join(outputDir, 'api', groupFolder);
-                baseName = 'api_group';
+                baseName = this.sanitizeFilename(doc.name);
             }
             else if (doc.type === 'query' && doc.apiGroup) {
-                // query in group "test" → api/test/{query_name}.xs
-                const groupFolder = snakeCase(doc.apiGroup);
+                // query in group "test" → api/{resolved_folder}/{query_name}.xs
+                const groupFolder = getApiGroupFolder(doc.apiGroup);
                 const nameParts = doc.name.split('/');
                 const leafName = nameParts.pop();
                 const folderParts = nameParts.map((part) => snakeCase(part));

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

@@ -4,7 +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';
+import { buildDocumentKey, findFilesWithGuid, parseDocument } from '../../../utils/document-parser.js';
 export default class Push extends BaseCommand {
     static args = {
         directory: Args.string({
@@ -201,6 +201,15 @@ Push schema only, skip records and environment variables
                 catch {
                     errorMessage += `\n${errorText}`;
                 }
+                // Surface local files involved in duplicate GUID errors
+                const guidMatch = errorMessage.match(/Duplicate \w+ guid: (\S+)/);
+                if (guidMatch) {
+                    const dupeFiles = findFilesWithGuid(documentEntries, guidMatch[1]);
+                    if (dupeFiles.length > 0) {
+                        const relPaths = dupeFiles.map((f) => path.relative(inputDir, f));
+                        errorMessage += `\n  Local files with this GUID:\n${relPaths.map((f) => `    ${f}`).join('\n')}`;
+                    }
+                }
                 this.error(errorMessage);
             }
             // Parse the response for GUID map

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

@@ -1,6 +1,8 @@
 export interface ParsedDocument {
     apiGroup?: string;
+    canonical?: string;
     content: string;
+    guid?: string;
     name: string;
     type: string;
     verb?: string;
@@ -15,3 +17,23 @@ export declare function parseDocument(content: string): null | ParsedDocument;
  * Used to match server GUID map entries back to local files.
  */
 export declare function buildDocumentKey(type: string, name: string, verb?: string, apiGroup?: string): string;
+/**
+ * Build a map of api_group name → unique folder name for a set of documents.
+ *
+ * When two api_groups produce the same snakeCase folder (e.g., "Authentication" and
+ * "authentication" both → "authentication"), the first group keeps the base name
+ * and subsequent groups get a numeric suffix (authentication_2, authentication_3, etc.).
+ *
+ * @param documents - Parsed documents (only api_group type docs are considered)
+ * @param snakeCaseFn - The snakeCase function to use for folder name generation
+ * @returns A function that resolves an api_group name to its unique folder name
+ */
+export declare function buildApiGroupFolderResolver(documents: ParsedDocument[], snakeCaseFn: (s: string) => string): (groupName: string) => string;
+/**
+ * Find local .xs files that contain a specific GUID.
+ * Used to surface which files are involved when the server reports a duplicate GUID error.
+ */
+export declare function findFilesWithGuid(entries: Array<{
+    content: string;
+    filePath: string;
+}>, guid: string): string[];

package/dist/utils/document-parser.js

@@ -45,7 +45,19 @@ export function parseDocument(content) {
     if (apiGroupMatch) {
         apiGroup = apiGroupMatch[1];
     }
-    return { apiGroup, content, name, type, verb };
+    // Extract canonical if present (e.g., canonical = "abc123")
+    let canonical;
+    const canonicalMatch = content.match(/canonical\s*=\s*"([^"]*)"/);
+    if (canonicalMatch) {
+        canonical = canonicalMatch[1];
+    }
+    // Extract guid if present (e.g., guid = "abc123")
+    let guid;
+    const guidMatch = content.match(/guid\s*=\s*"([^"]*)"/);
+    if (guidMatch) {
+        guid = guidMatch[1];
+    }
+    return { apiGroup, canonical, content, guid, name, type, verb };
 }
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.
@@ -59,3 +71,44 @@ export function buildDocumentKey(type, name, verb, apiGroup) {
         parts.push(apiGroup);
     return parts.join(':');
 }
+/**
+ * Build a map of api_group name → unique folder name for a set of documents.
+ *
+ * When two api_groups produce the same snakeCase folder (e.g., "Authentication" and
+ * "authentication" both → "authentication"), the first group keeps the base name
+ * and subsequent groups get a numeric suffix (authentication_2, authentication_3, etc.).
+ *
+ * @param documents - Parsed documents (only api_group type docs are considered)
+ * @param snakeCaseFn - The snakeCase function to use for folder name generation
+ * @returns A function that resolves an api_group name to its unique folder name
+ */
+export function buildApiGroupFolderResolver(documents, snakeCaseFn) {
+    const apiGroupFolderMap = new Map();
+    const folderClaims = new Map();
+    for (const doc of documents) {
+        if (doc.type !== 'api_group')
+            continue;
+        const folder = snakeCaseFn(doc.name);
+        const names = folderClaims.get(folder) ?? [];
+        if (!names.includes(doc.name)) {
+            names.push(doc.name);
+        }
+        folderClaims.set(folder, names);
+    }
+    for (const [folder, names] of folderClaims) {
+        apiGroupFolderMap.set(names[0], folder);
+        for (let i = 1; i < names.length; i++) {
+            apiGroupFolderMap.set(names[i], `${folder}_${i + 1}`);
+        }
+    }
+    return (groupName) => {
+        return apiGroupFolderMap.get(groupName) ?? snakeCaseFn(groupName);
+    };
+}
+/**
+ * Find local .xs files that contain a specific GUID.
+ * Used to surface which files are involved when the server reports a duplicate GUID error.
+ */
+export function findFilesWithGuid(entries, guid) {
+    return entries.filter((e) => e.content.includes(guid)).map((e) => e.filePath);
+}