@lowdefy/build 3.23.2 → 4.0.0-alpha.10

package/dist/build/buildRefs/recursiveBuild.js

@@ -0,0 +1,68 @@
+/*
+  Copyright 2020-2022 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 evaluateBuildOperators from './evaluateBuildOperators.js';
+import getRefContent from './getRefContent.js';
+import getRefsFromFile from './getRefsFromFile.js';
+import populateRefs from './populateRefs.js';
+import runTransformer from './runTransformer.js';
+async function recursiveParseFile({ context , refDef , count , referencedFrom  }) {
+    // TODO: Maybe it would be better to detect a cycle, since this is the real issue here?
+    if (count > 40) {
+        throw new Error(`Maximum recursion depth of references exceeded.`);
+    }
+    let fileContent = await getRefContent({
+        context,
+        refDef,
+        referencedFrom
+    });
+    const { foundRefs , fileContentBuiltRefs  } = getRefsFromFile(fileContent);
+    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
+    // deepest nodes first we for loop over over foundRefs one by one, awaiting each result.
+    // eslint-disable-next-line no-restricted-syntax
+    for (const newRefDef of foundRefs.values()){
+        // Parse vars and path before passing down to parse new file
+        const parsedRefDef = populateRefs({
+            toPopulate: newRefDef,
+            parsedFiles,
+            refDef
+        });
+        const parsedFile = await recursiveParseFile({
+            context,
+            refDef: parsedRefDef,
+            count: count + 1,
+            referencedFrom: refDef.path
+        });
+        const evaluatedOperators = await evaluateBuildOperators({
+            context,
+            input: parsedFile,
+            refDef: parsedRefDef
+        });
+        const transformedFile = await runTransformer({
+            context,
+            input: evaluatedOperators,
+            refDef: parsedRefDef
+        });
+        parsedFiles[newRefDef.id] = transformedFile;
+    }
+    return populateRefs({
+        toPopulate: fileContentBuiltRefs,
+        parsedFiles,
+        refDef
+    });
+}
+export default recursiveParseFile;

package/dist/build/buildRefs/runRefResolver.js

@@ -0,0 +1,33 @@
+/*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+import getUserJavascriptFunction from './getUserJavascriptFunction.js';
+async function runRefResolver({ context , refDef , referencedFrom  }) {
+    const resolverFn = await getUserJavascriptFunction({
+        context,
+        filePath: refDef.resolver || context.refResolver
+    });
+    let content;
+    try {
+        content = await resolverFn(refDef.path, refDef.vars, context);
+    } catch (error) {
+        throw new Error(`Error calling resolver "${refDef.resolver}" from "${referencedFrom}": ${error.message}`);
+    }
+    if (type.isNone(content)) {
+        throw new Error(`Tried to reference with resolver "${refDef.resolver}" from "${referencedFrom}", but received "${content}".`);
+    }
+    return content;
+}
+export default runRefResolver;

package/dist/build/buildRefs/runTransformer.js

@@ -0,0 +1,30 @@
+/*
+  Copyright 2020-2022 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 getUserJavascriptFunction from './getUserJavascriptFunction.js';
+async function runTransformer({ context , input , refDef  }) {
+    if (refDef.transformer) {
+        const transformerFn = await getUserJavascriptFunction({
+            context,
+            filePath: refDef.transformer
+        });
+        try {
+            return transformerFn(input, refDef.vars);
+        } catch (error) {
+            throw Error(`Error calling transformer "${refDef.transformer}" from "${refDef.path}": ${error.message}`);
+        }
+    }
+    return input;
+}
+export default runTransformer;

package/dist/build/buildStyles.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2022 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.
+*/ function buildStyles({ components , context  }) {
+    components.styles = [];
+    const styles = new Set();
+    Object.entries(components.types.blocks).forEach(([blockName, block])=>{
+        styles.add(...(context.typesMap.styles.packages[block.package] || []).map((style)=>`${block.package}/${style}`
+        ));
+        styles.add(...(context.typesMap.styles.blocks[blockName] || []).map((style)=>`${block.package}/${style}`
+        ));
+    });
+    components.styles = [
+        ...styles
+    ].filter((style)=>!!style
+    );
+}
+export default buildStyles;

package/dist/build/buildTypes.js

@@ -0,0 +1,96 @@
+/*
+  Copyright 2020-2022 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 basicTypes from '@lowdefy/blocks-basic/types';
+import loaderTypes from '@lowdefy/blocks-loaders/types';
+function buildTypeClass(context, { counter , definitions , store , typeClass , warnIfMissing =false  }) {
+    const counts = counter.getCounts();
+    Object.keys(counts).forEach((typeName)=>{
+        if (!definitions[typeName]) {
+            if (warnIfMissing) {
+                context.logger.warn(`${typeClass} type "${typeName}" was used but is not defined.`);
+                return;
+            }
+            throw new Error(`${typeClass} type "${typeName}" was used but is not defined.`);
+        }
+        store[typeName] = {
+            originalTypeName: definitions[typeName].originalTypeName,
+            package: definitions[typeName].package,
+            version: definitions[typeName].version,
+            count: counts[typeName]
+        };
+    });
+}
+function buildTypes({ components , context  }) {
+    const { typeCounters  } = context;
+    // Add Mandatory Types
+    // Add operators used by form validation
+    typeCounters.operators.client.increment('_not');
+    typeCounters.operators.client.increment('_type');
+    // Add loaders and basic
+    basicTypes.blocks.forEach((block)=>typeCounters.blocks.increment(block)
+    );
+    loaderTypes.blocks.forEach((block)=>typeCounters.blocks.increment(block)
+    );
+    typeCounters.blocks.increment('Message'); // Used for DisplayMessage in @lowdefy/client
+    components.types = {
+        actions: {},
+        blocks: {},
+        connections: {},
+        requests: {},
+        operators: {
+            client: {},
+            server: {}
+        }
+    };
+    buildTypeClass(context, {
+        counter: typeCounters.actions,
+        definitions: context.typesMap.actions,
+        store: components.types.actions,
+        typeClass: 'Action'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.blocks,
+        definitions: context.typesMap.blocks,
+        store: components.types.blocks,
+        typeClass: 'Block'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.connections,
+        definitions: context.typesMap.connections,
+        store: components.types.connections,
+        typeClass: 'Connection'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.requests,
+        definitions: context.typesMap.requests,
+        store: components.types.requests,
+        typeClass: 'Request'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.operators.client,
+        definitions: context.typesMap.operators.client,
+        store: components.types.operators.client,
+        typeClass: 'Operator',
+        warnIfMissing: true
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.operators.server,
+        definitions: context.typesMap.operators.server,
+        store: components.types.operators.server,
+        typeClass: 'Operator',
+        warnIfMissing: true
+    });
+}
+export default buildTypes;

package/dist/build/cleanBuildDirectory.js

@@ -0,0 +1,19 @@
+/*
+  Copyright 2020-2022 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 { cleanDirectory } from '@lowdefy/node-utils';
+async function cleanBuildDirectory({ context  }) {
+    await cleanDirectory(context.directories.build);
+}
+export default cleanBuildDirectory;

package/dist/build/copyPublicFolder.js

@@ -0,0 +1,23 @@
+/*
+  Copyright 2020-2022 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 path from 'path';
+import fs from 'fs';
+import { copyDirectory } from '@lowdefy/node-utils';
+async function copyPublicFolder({ context  }) {
+    if (context.directories.config === context.directories.server) return;
+    if (!fs.existsSync(path.resolve(context.directories.config, 'public'))) return;
+    await copyDirectory(path.resolve(context.directories.config, 'public'), path.resolve(context.directories.server, 'public'));
+}
+export default copyPublicFolder;

package/dist/build/testSchema.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2022 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 { validate } from '@lowdefy/ajv';
+import lowdefySchema from '../lowdefySchema.js';
+import formatErrorMessage from '../utils/formatErrorMessage.js';
+async function testSchema({ components , context  }) {
+    const { valid , errors  } = validate({
+        schema: lowdefySchema,
+        data: components,
+        returnErrors: true
+    });
+    if (!valid) {
+        await context.logger.warn('Schema not valid.');
+        const promises = errors.map((error)=>context.logger.warn(formatErrorMessage({
+                error,
+                components
+            }))
+        );
+        await promises;
+    }
+}
+export default testSchema;

package/dist/build/updateServerPackageJson.js

@@ -0,0 +1,46 @@
+/*
+  Copyright 2020-2022 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 path from 'path';
+import { readFile, writeFile } from '@lowdefy/node-utils';
+async function updateServerPackageJson({ components , context  }) {
+    const filePath = path.join(context.directories.server, 'package.json');
+    const packageJsonContent = await readFile(filePath);
+    const packageJson = JSON.parse(packageJsonContent);
+    const dependencies = packageJson.dependencies;
+    function getPackages(types) {
+        Object.values(types).forEach((type)=>{
+            dependencies[type.package] = type.version;
+        });
+    }
+    getPackages(components.types.actions);
+    getPackages(components.types.blocks);
+    getPackages(components.types.connections);
+    getPackages(components.types.requests);
+    getPackages(components.types.operators.client);
+    getPackages(components.types.operators.server);
+    // Sort dependencies
+    packageJson.dependencies = {};
+    Object.keys(dependencies).sort().forEach((name)=>{
+        packageJson.dependencies[name] = dependencies[name];
+    });
+    const newPackageJsonContent = JSON.stringify(packageJson, null, 2).concat('\n');
+    // Only write package.json if it has changed since dev server will
+    // be watching the file to trigger reinstalls
+    if (newPackageJsonContent !== packageJsonContent) {
+        context.logger.warn('Plugin dependencies have changed. Updating "package.json".');
+        await writeFile(filePath, newPackageJsonContent);
+    }
+}
+export default updateServerPackageJson;

package/dist/build/validateApp.js

@@ -0,0 +1,34 @@
+/* eslint-disable no-param-reassign */ /*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+async function validateApp({ components  }) {
+    if (type.isNone(components.app)) {
+        components.app = {};
+    }
+    if (!type.isObject(components.app)) {
+        throw new Error('lowdefy.app is not an object.');
+    }
+    if (type.isNone(components.app.html)) {
+        components.app.html = {};
+    }
+    if (type.isNone(components.app.html.appendBody)) {
+        components.app.html.appendBody = '';
+    }
+    if (type.isNone(components.app.html.appendHead)) {
+        components.app.html.appendHead = '';
+    }
+    return components;
+}
+export default validateApp;

package/dist/build/validateConfig.js

@@ -0,0 +1,57 @@
+/* eslint-disable no-param-reassign */ /*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+import { validate } from '@lowdefy/ajv';
+import lowdefySchema from '../lowdefySchema.js';
+async function validateConfig({ components  }) {
+    if (type.isNone(components.config)) {
+        components.config = {};
+    }
+    if (!type.isObject(components.config)) {
+        throw new Error('lowdefy.config is not an object.');
+    }
+    if (type.isNone(components.config.auth)) {
+        components.config.auth = {};
+    }
+    if (type.isNone(components.config.auth.pages)) {
+        components.config.auth.pages = {};
+    }
+    if (type.isNone(components.config.auth.pages.roles)) {
+        components.config.auth.pages.roles = {};
+    }
+    if (type.isNone(components.config.theme)) {
+        components.config.theme = {};
+    }
+    if (type.isString(components.config.basePath)) {
+        if (components.config.basePath[0] !== '/') {
+            throw Error('Base path must start with "/".');
+        }
+    }
+    validate({
+        schema: lowdefySchema.definitions.authConfig,
+        data: components.config.auth
+    });
+    if (components.config.auth.pages.protected === true && components.config.auth.pages.public === true || type.isArray(components.config.auth.pages.protected) && type.isArray(components.config.auth.pages.public)) {
+        throw new Error('Protected and public pages are mutually exclusive. When protected pages are listed, all unlisted pages are public by default and visa versa.');
+    }
+    if (components.config.auth.pages.protected === false) {
+        throw new Error('Protected pages can not be set to false.');
+    }
+    if (components.config.auth.pages.public === false) {
+        throw new Error('Public pages can not be set to false.');
+    }
+    return components;
+}
+export default validateConfig;

package/dist/build/writeApp.js

@@ -0,0 +1,18 @@
+/*
+  Copyright 2020-2022 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 writeApp({ components , context  }) {
+    await context.writeBuildArtifact('app.json', JSON.stringify(components.app || {}, null, 2));
+}
+export default writeApp;

package/dist/build/writeConfig.js

@@ -0,0 +1,18 @@
+/*
+  Copyright 2020-2022 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 writeConfig({ components , context  }) {
+    await context.writeBuildArtifact('config.json', JSON.stringify(components.config || {}, null, 2));
+}
+export default writeConfig;

package/dist/build/writeConnections.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+async function writeConnections({ components , context  }) {
+    if (type.isNone(components.connections)) return;
+    if (!type.isArray(components.connections)) {
+        throw new Error(`Connections is not an array.`);
+    }
+    const writePromises = components.connections.map(async (connection)=>{
+        await context.writeBuildArtifact(`connections/${connection.connectionId}.json`, JSON.stringify(connection, null, 2));
+    });
+    return Promise.all(writePromises);
+}
+export default writeConnections;

package/dist/build/writeGlobal.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+async function writeGlobal({ components , context  }) {
+    if (type.isNone(components.global)) {
+        components.global = {};
+    }
+    if (!type.isObject(components.global)) {
+        throw new Error('Global is not an object.');
+    }
+    await context.writeBuildArtifact('global.json', JSON.stringify(components.global, null, 2));
+}
+export default writeGlobal;

package/dist/build/writeMenus.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2022 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 { type } from '@lowdefy/helpers';
+async function writeMenus({ components , context  }) {
+    if (!type.isArray(components.menus)) {
+        throw new Error('Menus is not an array.');
+    }
+    await context.writeBuildArtifact('menus.json', JSON.stringify(components.menus, null, 2));
+}
+export default writeMenus;

package/dist/build/writePages.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2022 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 writePage({ page , context  }) {
+    await context.writeBuildArtifact(`pages/${page.pageId}/${page.pageId}.json`, JSON.stringify(page, null, 2));
+}
+async function writePages({ components , context  }) {
+    const writePromises = components.pages.map((page)=>writePage({
+            page,
+            context
+        })
+    );
+    return Promise.all(writePromises);
+}
+export default writePages;

package/dist/build/writePluginImports/generateImportFile.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2022 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 { nunjucksFunction } from '@lowdefy/nunjucks';
+const template = `{%- for import in imports -%}
+import { {{ import.originalTypeName }} as {{ import.typeName }} } from '{{ import.package }}/{{ importPath }}';
+{% endfor -%}
+export default {
+  {% for import in imports -%}
+  {{ import.typeName }},
+  {% endfor -%}
+};`;
+function generateImportFile({ types , importPath  }) {
+    const templateFn = nunjucksFunction(template);
+    const imports = Object.keys(types).map((typeName)=>({
+            typeName,
+            ...types[typeName]
+        })
+    );
+    return templateFn({
+        imports,
+        importPath
+    });
+}
+export default generateImportFile;