@lowdefy/build 0.0.0-experimental-20250702125311 → 0.0.0-experimental-20250910140832

package/dist/build/buildJs/writeJs.js

@@ -20,7 +20,7 @@ async function writeJs({ context }) {
     }));
     await context.writeBuildArtifact('plugins/operators/serverJsMap.js', generateJsFile({
         map: context.jsMap.server,
-        functionPrototype: `{ payload, secrets, user, step, item, state }`
+        functionPrototype: `{ item, payload, secrets, state, step, user }`
     }));
 }
 export default writeJs;

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;