@lowdefy/build 0.0.0-experimental-20250903141200 → 0.0.0-experimental-20250911081238

package/dist/build/buildRefs/buildRefs.js

@@ -17,12 +17,10 @@ import makeRefDefinition from './makeRefDefinition.js';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
 async function buildRefs({ context }) {
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
-    const refCache = new Map();
     let components = await recursiveBuild({
         context,
         refDef,
-        count: 0,
-        refCache
+        count: 0
     });
     components = await evaluateBuildOperators({
         context,

package/dist/build/buildRefs/getRefContent.js

@@ -17,7 +17,13 @@ import parseRefContent from './parseRefContent.js';
 import runRefResolver from './runRefResolver.js';
 async function getRefContent({ context, refDef, referencedFrom }) {
     let content;
-    if (refDef.resolver || context.refResolver) {
+    if (refDef.path === 'lowdefy.yaml' || refDef.path === 'lowdefy.yml') {
+        content = await getConfigFile({
+            context,
+            refDef,
+            referencedFrom
+        });
+    } else if (refDef.resolver || context.refResolver) {
         content = await runRefResolver({
             context,
             refDef,

package/dist/build/buildRefs/makeRefDefinition.js

@@ -14,9 +14,16 @@
   limitations under the License.
 */ import { get } from '@lowdefy/helpers';
 import getRefPath from './getRefPath.js';
-import makeRefHash from '../../utils/makeRefHash.js';
+import makeId from '../../utils/makeId.js';
 function makeRefDefinition(refDefinition, parent, refMap) {
+    const id = makeId();
     const refDef = {
+        parent
+    };
+    refMap[id] = refDef;
+    return {
+        ...refDef,
+        id,
         key: get(refDefinition, 'key'),
         original: refDefinition,
         path: getRefPath(refDefinition),
@@ -26,12 +33,5 @@ function makeRefDefinition(refDefinition, parent, refMap) {
             default: {}
         })
     };
-    const refHash = makeRefHash(refDef);
-    refMap[refHash] = {
-        parent
-    };
-    refDef.hash = refHash;
-    refDef.parent = parent;
-    return refDef;
 }
 export default makeRefDefinition;

package/dist/build/buildRefs/populateRefs.js

@@ -16,7 +16,7 @@
 function refReviver(key, value) {
     if (type.isObject(value)) {
         if (!type.isUndefined(value._ref)) {
-            return this.refCache.get(value._ref.hash);
+            return this.parsedFiles[value._ref.id];
         }
         if (value._var) {
             if (type.isString(value._var)) {
@@ -34,9 +34,9 @@ function refReviver(key, value) {
     }
     return value;
 }
-function populateRefs({ refCache, refDef, toPopulate }) {
+function populateRefs({ parsedFiles, refDef, toPopulate }) {
     return JSON.parse(JSON.stringify(toPopulate), refReviver.bind({
-        refCache,
+        parsedFiles,
         vars: refDef.vars
     }));
 }

package/dist/build/buildRefs/recursiveBuild.js

@@ -19,20 +19,18 @@ import getRefContent from './getRefContent.js';
 import getRefsFromFile from './getRefsFromFile.js';
 import populateRefs from './populateRefs.js';
 import runTransformer from './runTransformer.js';
-async function recursiveBuild({ context, refDef, count, referencedFrom, refCache }) {
+async function recursiveBuild({ context, refDef, count, referencedFrom }) {
     // TODO: Maybe it would be better to detect a cycle, since this is the real issue here?
     if (count > 10000) {
         throw new Error(`Maximum recursion depth of references exceeded.`);
     }
-    if (refCache.has(refDef.hash)) {
-        return refCache.get(refDef.hash);
-    }
     let fileContent = await getRefContent({
         context,
         refDef,
         referencedFrom
     });
-    const { foundRefs, fileContentBuiltRefs } = getRefsFromFile(fileContent, refDef.hash, context.refMap);
+    const { foundRefs, fileContentBuiltRefs } = getRefsFromFile(fileContent, refDef.id, context.refMap);
+    const parsedFiles = {};
     // Since we can have references in the variables of a reference, we need to first parse
     // the deeper nodes, so we can use those parsed files in references higher in the tree.
     // To do this, since foundRefs is an array of ref definitions that are in order of the
@@ -41,16 +39,15 @@ async function recursiveBuild({ context, refDef, count, referencedFrom, refCache
         // Parse vars and path before passing down to parse new file
         const parsedRefDef = populateRefs({
             toPopulate: newRefDef,
-            refCache,
+            parsedFiles,
             refDef
         });
-        context.refMap[parsedRefDef.hash].path = parsedRefDef.path;
+        context.refMap[parsedRefDef.id].path = parsedRefDef.path;
         const parsedFile = await recursiveBuild({
             context,
             refDef: parsedRefDef,
             count: count + 1,
-            referencedFrom: refDef.path,
-            refCache
+            referencedFrom: refDef.path
         });
         const transformedFile = await runTransformer({
             context,
@@ -70,21 +67,19 @@ async function recursiveBuild({ context, refDef, count, referencedFrom, refCache
         const reviver = (_, value)=>{
             if (!type.isObject(value)) return value;
             Object.defineProperty(value, '~r', {
-                value: refDef.hash,
+                value: refDef.id,
                 enumerable: false,
                 writable: true,
                 configurable: true
             });
             return value;
         };
-        refCache.set(newRefDef.hash, JSON.parse(JSON.stringify(withRefKey), reviver));
+        parsedFiles[newRefDef.id] = JSON.parse(JSON.stringify(withRefKey), reviver);
     }
-    const result = populateRefs({
+    return populateRefs({
         toPopulate: fileContentBuiltRefs,
-        refCache,
+        parsedFiles,
         refDef
     });
-    refCache.set(refDef.hash, result);
-    return result;
 }
 export default recursiveBuild;

package/dist/build/writePluginSchemas/writeActionSchemas.js

@@ -0,0 +1,32 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ async function writeActionSchemas({ context }) {
+    try {
+        const actions = context.typesMap.actions || {};
+        for (const [actionType, actionConfig] of Object.entries(actions)){
+            const actionSchema = {
+                type: actionType,
+                package: actionConfig.package,
+                description: `${actionType} action`
+            };
+            const schemaFileName = `${actionType}.json`;
+            const individualSchemaContent = JSON.stringify(actionSchema, null, 2);
+            await context.writeBuildArtifact(`schemas/actions/${schemaFileName}`, individualSchemaContent);
+        }
+    } catch (error) {
+        context.logger.warn('Failed to write action schemas:', error.message);
+    }
+}
+export default writeActionSchemas;

package/dist/build/writePluginSchemas/writeBlockSchemas.js

@@ -0,0 +1,47 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+async function writeBlockSchemas({ context }) {
+    try {
+        const blocks = context.typesMap.blocks || {};
+        for (const [blockType, blockConfig] of Object.entries(blocks)){
+            const blockSchema = {
+                type: blockType,
+                package: blockConfig.package,
+                description: `${blockType} block`
+            };
+            // Try to read schema.json from the package
+            try {
+                const packagePath = path.join(process.cwd(), 'node_modules', blockConfig.package);
+                const schemaPath = path.join(packagePath, 'dist', 'blocks', blockConfig.originalTypeName, 'schema.json');
+                if (fs.existsSync(schemaPath)) {
+                    const schemaContent = fs.readFileSync(schemaPath, 'utf8');
+                    const schema = JSON.parse(schemaContent);
+                    blockSchema.schema = schema;
+                }
+            } catch (error) {
+                // Continue without schema if it can't be read
+                context.logger.warn(`Could not read schema for ${blockType}:`, error.message);
+            }
+            const schemaFileName = `${blockType}.json`;
+            const individualSchemaContent = JSON.stringify(blockSchema, null, 2);
+            await context.writeBuildArtifact(`schemas/blocks/${schemaFileName}`, individualSchemaContent);
+        }
+    } catch (error) {
+        context.logger.warn('Failed to write block schemas:', error.message);
+    }
+}
+export default writeBlockSchemas;

package/dist/build/writePluginSchemas/writeConnectionSchemas.js

@@ -0,0 +1,52 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+import writeRequestSchemas from './writeRequestSchemas.js';
+async function writeConnectionSchemas({ context }) {
+    try {
+        const connections = context.typesMap.connections || {};
+        for (const [connectionType, connectionConfig] of Object.entries(connections)){
+            const connectionSchema = {
+                type: connectionType,
+                package: connectionConfig.package,
+                description: `${connectionType} connection`
+            };
+            // Try to read schema.js from the package
+            try {
+                const packagePath = path.join(process.cwd(), 'node_modules', connectionConfig.package);
+                const schemaPath = path.join(packagePath, 'dist', 'connections', connectionConfig.originalTypeName, 'schema.js');
+                if (fs.existsSync(schemaPath)) {
+                    const { default: schema } = await import(`file://${schemaPath}`);
+                    connectionSchema.schema = schema;
+                }
+            } catch (error) {
+                // Continue without schema if it can't be read
+                context.logger.warn(`Could not read schema for ${connectionType}:`, error.message);
+            }
+            const schemaFileName = `${connectionType}.json`;
+            const individualSchemaContent = JSON.stringify(connectionSchema, null, 2);
+            await context.writeBuildArtifact(`schemas/connections/${schemaFileName}`, individualSchemaContent);
+            await writeRequestSchemas({
+                connectionType,
+                context,
+                connectionPackage: connectionConfig.package
+            });
+        }
+    } catch (error) {
+        context.logger.warn('Failed to write connection schemas:', error.message);
+    }
+}
+export default writeConnectionSchemas;

package/dist/build/writePluginSchemas/writeOperatorSchemas.js

@@ -0,0 +1,62 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ async function writeOperatorSchemas({ context }) {
+    try {
+        const operators = context.typesMap.operators || {};
+        const allOperators = {};
+        // Process client operators
+        if (operators.client) {
+            for (const [operatorType, operatorConfig] of Object.entries(operators.client)){
+                allOperators[operatorType] = {
+                    ...operatorConfig,
+                    groups: [
+                        'client'
+                    ]
+                };
+            }
+        }
+        // Process server operators
+        if (operators.server) {
+            for (const [operatorType, operatorConfig] of Object.entries(operators.server)){
+                if (allOperators[operatorType]) {
+                    // Operator exists in both client and server
+                    allOperators[operatorType].groups.push('server');
+                } else {
+                    // Operator only in server
+                    allOperators[operatorType] = {
+                        ...operatorConfig,
+                        groups: [
+                            'server'
+                        ]
+                    };
+                }
+            }
+        }
+        for (const [operatorType, operatorConfig] of Object.entries(allOperators)){
+            const operatorSchema = {
+                type: operatorType,
+                package: operatorConfig.package,
+                groups: operatorConfig.groups,
+                description: `${operatorType} operator`
+            };
+            const schemaFileName = `${operatorType}.json`;
+            const individualSchemaContent = JSON.stringify(operatorSchema, null, 2);
+            await context.writeBuildArtifact(`schemas/operators/${schemaFileName}`, individualSchemaContent);
+        }
+    } catch (error) {
+        context.logger.warn('Failed to write operator schemas:', error.message);
+    }
+}
+export default writeOperatorSchemas;

package/dist/build/writePluginSchemas/writePluginSchemas.js

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import writeActionSchemas from './writeActionSchemas.js';
+import writeBlockSchemas from './writeBlockSchemas.js';
+import writeConnectionSchemas from './writeConnectionSchemas.js';
+import writeOperatorSchemas from './writeOperatorSchemas.js';
+async function writePluginSchemas({ context }) {
+    if (context.stage !== 'dev') {
+        return;
+    }
+    await Promise.all([
+        writeActionSchemas({
+            context
+        }),
+        writeBlockSchemas({
+            context
+        }),
+        writeConnectionSchemas({
+            context
+        }),
+        writeOperatorSchemas({
+            context
+        })
+    ]);
+}
+export default writePluginSchemas;

package/dist/build/writePluginSchemas/writeRequestSchemas.js

@@ -0,0 +1,49 @@
+/*
+  Copyright 2020-2024 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import fs from 'fs';
+import path from 'path';
+async function writeRequestSchemas({ connectionType, context, connectionPackage }) {
+    try {
+        const allRequests = context.typesMap.requests || {};
+        // Filter requests that belong to this connection package
+        const requests = Object.fromEntries(Object.entries(allRequests).filter(([, requestConfig])=>requestConfig.package === connectionPackage));
+        for (const [requestType, requestConfig] of Object.entries(requests)){
+            const requestSchema = {
+                connection: connectionType,
+                type: requestType,
+                package: requestConfig.package,
+                description: `${requestType} request`
+            };
+            // Try to read schema.js from the package
+            try {
+                const packagePath = path.join(process.cwd(), 'node_modules', requestConfig.package);
+                const schemaPath = path.join(packagePath, 'dist', 'connections', connectionType, requestConfig.originalTypeName, 'schema.js');
+                if (fs.existsSync(schemaPath)) {
+                    const { default: schema } = await import(`file://${schemaPath}`);
+                    requestSchema.schema = schema;
+                }
+            } catch (error) {
+                // Continue without schema if it can't be read
+                context.logger.warn(`Could not read schema for ${requestType}:`, error.message);
+            }
+            const schemaFileName = `${requestType}.json`;
+            const individualSchemaContent = JSON.stringify(requestSchema, null, 2);
+            await context.writeBuildArtifact(`schemas/requests/${connectionType}/${schemaFileName}`, individualSchemaContent);
+        }
+    } catch (error) {
+        context.logger.warn('Failed to write request schemas:', error.message);
+    }
+}
+export default writeRequestSchemas;