@n8n/workflow-sdk 0.34.1 → 0.35.1

package/dist/generate-types/generate-types.d.ts

@@ -123,7 +123,9 @@ export interface JsonSchema {
     const?: unknown;
     $ref?: string;
 }
+export declare function withSchemaDirIndex<T>(fn: () => Promise<T>): Promise<T>;
 export declare function schemaSearchRoots(): string[];
+export declare function findSchemaDirectory(baseName: string, schemaPath?: string): string | undefined;
 export declare function discoverSchemasForNode(nodeName: string, version: number, schemaPath?: string): OutputSchema[];
 export declare function padVersion(version: number): string;
 export declare function computeSchemaCorpusHash(baseDirs?: string[]): string;

package/dist/generate-types/generate-types.js

@@ -35,7 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NODES_BASE_TYPES = void 0;
 exports.isCustomApiCall = isCustomApiCall;
+exports.withSchemaDirIndex = withSchemaDirIndex;
 exports.schemaSearchRoots = schemaSearchRoots;
+exports.findSchemaDirectory = findSchemaDirectory;
 exports.discoverSchemasForNode = discoverSchemasForNode;
 exports.padVersion = padVersion;
 exports.computeSchemaCorpusHash = computeSchemaCorpusHash;
@@ -339,6 +341,70 @@ function findNestedSchemaDir(dir, targetNames) {
     }
     return undefined;
 }
+function buildSchemaRootIndex(root) {
+    const index = { flat: new Map(), nested: new Map() };
+    const walk = (dir, depth) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const entryPath = path.join(dir, entry.name);
+            const key = entry.name.toLowerCase();
+            const schemaPath = path.join(entryPath, '__schema__');
+            if (fs.existsSync(schemaPath)) {
+                if (depth === 0 && !index.flat.has(key))
+                    index.flat.set(key, schemaPath);
+                if (!index.nested.has(key))
+                    index.nested.set(key, schemaPath);
+            }
+            if (entry.name !== '__schema__' && entry.name !== 'node_modules') {
+                walk(entryPath, depth + 1);
+            }
+        }
+    };
+    walk(root, 0);
+    return index;
+}
+let activeSchemaIndexes;
+async function withSchemaDirIndex(fn) {
+    if (activeSchemaIndexes)
+        return await fn();
+    activeSchemaIndexes = new Map();
+    try {
+        return await fn();
+    }
+    finally {
+        activeSchemaIndexes = undefined;
+    }
+}
+function indexedSchemaDirectory(indexes, roots, baseName) {
+    const rootIndexes = roots.map((root) => {
+        let index = indexes.get(root);
+        if (!index) {
+            index = buildSchemaRootIndex(root);
+            indexes.set(root, index);
+        }
+        return index;
+    });
+    const key = baseName.toLowerCase();
+    for (const index of rootIndexes) {
+        const found = index.flat.get(key);
+        if (found)
+            return found;
+    }
+    for (const index of rootIndexes) {
+        const found = index.nested.get(key);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
 function schemaSearchRoots() {
     const cwdRoot = path.resolve(process.cwd(), 'dist', 'nodes');
     if (cwdRoot !== NODES_BASE_DIST && fs.existsSync(cwdRoot)) {
@@ -356,6 +422,9 @@ function findSchemaDirectory(baseName, schemaPath) {
             }
         }
     }
+    if (activeSchemaIndexes) {
+        return indexedSchemaDirectory(activeSchemaIndexes, roots, baseName);
+    }
     const possibleNames = [
         baseName.charAt(0).toUpperCase() + baseName.slice(1),
         baseName,
@@ -2867,6 +2936,9 @@ async function generateVersionSpecificFiles(packageDir, _packageName, nodesByNam
     return allNodes;
 }
 async function orchestrateGeneration(options) {
+    return await withSchemaDirIndex(async () => await generateAll(options));
+}
+async function generateAll(options) {
     const { nodes, outputDir } = options;
     const nodesByPackage = new Map();
     for (const node of nodes) {