@lowdefy/build 4.0.0-alpha.10 → 4.0.0-alpha.11

package/dist/build/buildAuth/buildAuth.js

@@ -12,38 +12,19 @@
   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 getPageRoles from './getPageRoles.js';
-import getProtectedPages from './getProtectedPages.js';
-function buildAuth({ components  }) {
-    const protectedPages = getProtectedPages({
+*/ import buildAuthPlugins from './buildAuthPlugins.js';
+import buildPageAuth from './buildPageAuth.js';
+import validateAuthConfig from './validateAuthConfig.js';
+function buildAuth({ components , context  }) {
+    validateAuthConfig({
         components
     });
-    const pageRoles = getPageRoles({
+    buildPageAuth({
         components
     });
-    let configPublicPages = [];
-    if (type.isArray(components.config.auth.pages.public)) {
-        configPublicPages = components.config.auth.pages.public;
-    }
-    (components.pages || []).forEach((page)=>{
-        if (pageRoles[page.id]) {
-            if (configPublicPages.includes(page.id)) {
-                throw new Error(`Page "${page.id}" is both protected by roles ${JSON.stringify(pageRoles[page.id])} and public.`);
-            }
-            page.auth = {
-                public: false,
-                roles: pageRoles[page.id]
-            };
-        } else if (protectedPages.includes(page.id)) {
-            page.auth = {
-                public: false
-            };
-        } else {
-            page.auth = {
-                public: true
-            };
-        }
+    buildAuthPlugins({
+        components,
+        context
     });
     return components;
 }

package/dist/build/buildAuth/buildAuthPlugins.js

@@ -0,0 +1,78 @@
+/*
+  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';
+function buildCallbacks({ components , context  }) {
+    if (type.isArray(components.auth.callbacks)) {
+        components.auth.callbacks.forEach((callback)=>{
+            if (type.isUndefined(callback.id)) {
+                throw new Error(`Auth callback id missing.`);
+            }
+            if (!type.isString(callback.id)) {
+                throw new Error(`Auth callback id is not a string. Received ${JSON.stringify(callback.id)}.`);
+            }
+            if (!type.isString(callback.type)) {
+                throw new Error(`Auth callback type is not a string at callback "${callback.id}". Received ${JSON.stringify(callback.type)}.`);
+            }
+            context.typeCounters.auth.callbacks.increment(callback.type);
+        });
+    }
+}
+function buildEvents({ components , context  }) {
+    if (type.isArray(components.auth.events)) {
+        components.auth.events.forEach((event)=>{
+            if (type.isUndefined(event.id)) {
+                throw new Error(`Auth event id missing.`);
+            }
+            if (!type.isString(event.id)) {
+                throw new Error(`Auth event id is not a string. Received ${JSON.stringify(event.id)}.`);
+            }
+            if (!type.isString(event.type)) {
+                throw new Error(`Auth event type is not a string at event "${event.id}". Received ${JSON.stringify(event.type)}.`);
+            }
+            context.typeCounters.auth.events.increment(event.type);
+        });
+    }
+}
+function buildProviders({ components , context  }) {
+    if (type.isArray(components.auth.providers)) {
+        components.auth.providers.forEach((provider)=>{
+            if (type.isUndefined(provider.id)) {
+                throw new Error(`Auth provider id missing.`);
+            }
+            if (!type.isString(provider.id)) {
+                throw new Error(`Auth provider id is not a string. Received ${JSON.stringify(provider.id)}.`);
+            }
+            if (!type.isString(provider.type)) {
+                throw new Error(`Auth provider type is not a string at provider "${provider.id}". Received ${JSON.stringify(provider.type)}.`);
+            }
+            context.typeCounters.auth.providers.increment(provider.type);
+        });
+    }
+}
+function buildAuthPlugins({ components , context  }) {
+    buildCallbacks({
+        components,
+        context
+    });
+    buildEvents({
+        components,
+        context
+    });
+    buildProviders({
+        components,
+        context
+    });
+}
+export default buildAuthPlugins;

package/dist/build/buildAuth/buildPageAuth.js

@@ -0,0 +1,50 @@
+/* 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 getPageRoles from './getPageRoles.js';
+import getProtectedPages from './getProtectedPages.js';
+function buildPageAuth({ components  }) {
+    const protectedPages = getProtectedPages({
+        components
+    });
+    const pageRoles = getPageRoles({
+        components
+    });
+    let configPublicPages = [];
+    if (type.isArray(components.auth.pages.public)) {
+        configPublicPages = components.auth.pages.public;
+    }
+    (components.pages || []).forEach((page)=>{
+        if (pageRoles[page.id]) {
+            if (configPublicPages.includes(page.id)) {
+                throw new Error(`Page "${page.id}" is both protected by roles ${JSON.stringify(pageRoles[page.id])} and public.`);
+            }
+            page.auth = {
+                public: false,
+                roles: pageRoles[page.id]
+            };
+        } else if (protectedPages.includes(page.id)) {
+            page.auth = {
+                public: false
+            };
+        } else {
+            page.auth = {
+                public: true
+            };
+        }
+    });
+    return components;
+}
+export default buildPageAuth;

package/dist/build/buildAuth/getPageRoles.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function getPageRoles({ components  }) {
-    const roles = components.config.auth.pages.roles;
+    const roles = components.auth.pages.roles;
     const pageRoles = {};
     Object.keys(roles).forEach((roleName)=>{
         roles[roleName].forEach((pageId)=>{

package/dist/build/buildAuth/getProtectedPages.js

@@ -17,13 +17,13 @@ function getProtectedPages({ components  }) {
     const pageIds = (components.pages || []).map((page)=>page.id
     );
     let protectedPages = [];
-    if (type.isArray(components.config.auth.pages.public)) {
-        protectedPages = pageIds.filter((pageId)=>!components.config.auth.pages.public.includes(pageId)
+    if (type.isArray(components.auth.pages.public)) {
+        protectedPages = pageIds.filter((pageId)=>!components.auth.pages.public.includes(pageId)
         );
-    } else if (components.config.auth.pages.protected === true) {
+    } else if (components.auth.pages.protected === true) {
         protectedPages = pageIds;
-    } else if (type.isArray(components.config.auth.pages.protected)) {
-        protectedPages = components.config.auth.pages.protected;
+    } else if (type.isArray(components.auth.pages.protected)) {
+        protectedPages = components.auth.pages.protected;
     }
     return protectedPages;
 }

package/dist/build/buildAuth/validateAuthConfig.js

@@ -0,0 +1,61 @@
+/* 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 validateAuthConfig({ components  }) {
+    if (type.isNone(components.auth)) {
+        components.auth = {};
+    }
+    if (!type.isObject(components.auth)) {
+        throw new Error('lowdefy.auth is not an object.');
+    }
+    if (type.isNone(components.auth.pages)) {
+        components.auth.pages = {};
+    }
+    if (type.isNone(components.auth.pages.roles)) {
+        components.auth.pages.roles = {};
+    }
+    if (type.isNone(components.auth.callbacks)) {
+        components.auth.callbacks = [];
+    }
+    if (type.isNone(components.auth.events)) {
+        components.auth.events = [];
+    }
+    if (type.isNone(components.auth.providers)) {
+        components.auth.providers = [];
+    }
+    if (type.isNone(components.auth.session)) {
+        components.auth.session = {};
+    }
+    if (type.isNone(components.auth.theme)) {
+        components.auth.theme = {};
+    }
+    validate({
+        schema: lowdefySchema.definitions.authConfig,
+        data: components.auth
+    });
+    if (components.auth.pages.protected === true && components.auth.pages.public === true || type.isArray(components.auth.pages.protected) && type.isArray(components.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.auth.pages.protected === false) {
+        throw new Error('Protected pages can not be set to false.');
+    }
+    if (components.auth.pages.public === false) {
+        throw new Error('Public pages can not be set to false.');
+    }
+    return components;
+}
+export default validateAuthConfig;

package/dist/build/{buildIcons.js → buildImports/buildIconImports.js}

@@ -49,9 +49,9 @@ function getConfigIcons({ components , icons , regex  }) {
     ].map((match)=>icons.add(match[1])
     );
 }
-function getBlockDefaultIcons({ components , context , icons , regex  }) {
-    Object.keys(components.types.blocks).forEach((blockName)=>{
-        (context.typesMap.icons[blockName] || []).forEach((icon)=>{
+function getBlockDefaultIcons({ blocks , context , icons , regex  }) {
+    blocks.forEach((block)=>{
+        (context.typesMap.icons[block.typeName] || []).forEach((icon)=>{
             [
                 ...JSON.stringify(icon).matchAll(regex)
             ].map((match)=>icons.add(match[1])
@@ -59,8 +59,8 @@ function getBlockDefaultIcons({ components , context , icons , regex  }) {
         });
     });
 }
-function buildIcons({ components , context  }) {
-    components.icons = [];
+function buildIconImports({ blocks , components , context  }) {
+    const iconImports = [];
     Object.entries(iconPackages).forEach(([iconPackage, regex])=>{
         const icons = new Set();
         // TODO: Can we do better than this?
@@ -75,17 +75,18 @@ function buildIcons({ components , context  }) {
             regex
         });
         getBlockDefaultIcons({
-            components,
+            blocks,
             context,
             icons,
             regex
         });
-        components.icons.push({
+        iconImports.push({
             icons: [
                 ...icons
             ],
             package: iconPackage
         });
     });
+    return iconImports;
 }
-export default buildIcons;
+export default buildIconImports;

package/dist/build/buildImports/buildImports.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 buildImportsDev from './buildImportsDev.js';
+import buildImportsProd from './buildImportsProd.js';
+function buildImports({ components , context  }) {
+    if (context.stage === 'dev') {
+        components.imports = buildImportsDev({
+            components,
+            context
+        });
+    } else {
+        components.imports = buildImportsProd({
+            components,
+            context
+        });
+    }
+}
+export default buildImports;

package/dist/build/buildImports/buildImportsDev.js

@@ -0,0 +1,101 @@
+/*
+  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 buildIconImports from './buildIconImports.js';
+import buildStyleImports from './buildStyleImports.js';
+function getPluginPackages({ components  }) {
+    const pluginPackages = new Set();
+    function getPackages(types) {
+        Object.values(types).forEach((type)=>{
+            pluginPackages.add(type.package);
+        });
+    }
+    getPackages(components.types.actions);
+    getPackages(components.types.auth.callbacks);
+    getPackages(components.types.auth.events);
+    getPackages(components.types.auth.providers);
+    getPackages(components.types.blocks);
+    getPackages(components.types.connections);
+    getPackages(components.types.requests);
+    getPackages(components.types.operators.client);
+    getPackages(components.types.operators.server);
+    return pluginPackages;
+}
+function buildImportClassDev({ pluginPackages , map  }) {
+    return Object.entries(map).map(([typeName, type])=>({
+            originalTypeName: type.originalTypeName,
+            package: type.package,
+            typeName
+        })
+    ).filter((type)=>pluginPackages.has(type.package)
+    );
+}
+function buildImportsDev({ components , context  }) {
+    const pluginPackages = getPluginPackages({
+        components
+    });
+    const blocks = buildImportClassDev({
+        pluginPackages,
+        map: context.typesMap.blocks
+    });
+    return {
+        actions: buildImportClassDev({
+            pluginPackages,
+            map: context.typesMap.actions
+        }),
+        auth: {
+            callbacks: buildImportClassDev({
+                pluginPackages,
+                map: context.typesMap.auth.callbacks
+            }),
+            events: buildImportClassDev({
+                pluginPackages,
+                map: context.typesMap.auth.events
+            }),
+            providers: buildImportClassDev({
+                pluginPackages,
+                map: context.typesMap.auth.providers
+            })
+        },
+        blocks,
+        connections: buildImportClassDev({
+            pluginPackages,
+            map: context.typesMap.connections
+        }),
+        icons: buildIconImports({
+            blocks,
+            components,
+            context
+        }),
+        requests: buildImportClassDev({
+            pluginPackages,
+            map: context.typesMap.requests
+        }),
+        operators: {
+            client: buildImportClassDev({
+                pluginPackages,
+                map: context.typesMap.operators.client
+            }),
+            server: buildImportClassDev({
+                pluginPackages,
+                map: context.typesMap.operators.server
+            })
+        },
+        styles: buildStyleImports({
+            blocks,
+            context
+        })
+    };
+}
+export default buildImportsDev;

package/dist/build/buildImports/buildImportsProd.js

@@ -0,0 +1,52 @@
+/*
+  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 buildIconImports from './buildIconImports.js';
+import buildStyleImports from './buildStyleImports.js';
+function buildImportClassProd(types) {
+    return Object.entries(types).map(([typeName, type])=>({
+            originalTypeName: type.originalTypeName,
+            package: type.package,
+            typeName
+        })
+    );
+}
+function buildImportsProd({ components , context  }) {
+    const blocks = buildImportClassProd(components.types.blocks);
+    return {
+        actions: buildImportClassProd(components.types.actions),
+        auth: {
+            callbacks: buildImportClassProd(components.types.auth.callbacks),
+            events: buildImportClassProd(components.types.auth.events),
+            providers: buildImportClassProd(components.types.auth.providers)
+        },
+        blocks,
+        connections: buildImportClassProd(components.types.connections),
+        icons: buildIconImports({
+            blocks,
+            components,
+            context
+        }),
+        requests: buildImportClassProd(components.types.requests),
+        operators: {
+            client: buildImportClassProd(components.types.operators.client),
+            server: buildImportClassProd(components.types.operators.server)
+        },
+        styles: buildStyleImports({
+            blocks,
+            context
+        })
+    };
+}
+export default buildImportsProd;

package/dist/build/{buildStyles.js → buildImports/buildStyleImports.js}

@@ -12,18 +12,17 @@
   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 = [];
+*/ function buildStyleImports({ blocks , context  }) {
     const styles = new Set();
-    Object.entries(components.types.blocks).forEach(([blockName, block])=>{
+    blocks.forEach((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}`
+        styles.add(...(context.typesMap.styles.blocks[block.typeName] || []).map((style)=>`${block.package}/${style}`
         ));
     });
-    components.styles = [
+    return [
         ...styles
     ].filter((style)=>!!style
     );
 }
-export default buildStyles;
+export default buildStyleImports;

package/dist/build/buildTypes.js

@@ -46,6 +46,11 @@ function buildTypes({ components , context  }) {
     typeCounters.blocks.increment('Message'); // Used for DisplayMessage in @lowdefy/client
     components.types = {
         actions: {},
+        auth: {
+            callbacks: {},
+            events: {},
+            providers: {}
+        },
         blocks: {},
         connections: {},
         requests: {},
@@ -60,6 +65,24 @@ function buildTypes({ components , context  }) {
         store: components.types.actions,
         typeClass: 'Action'
     });
+    buildTypeClass(context, {
+        counter: typeCounters.auth.callbacks,
+        definitions: context.typesMap.auth.callbacks,
+        store: components.types.auth.callbacks,
+        typeClass: 'Auth callback'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.auth.events,
+        definitions: context.typesMap.auth.events,
+        store: components.types.auth.events,
+        typeClass: 'Auth event'
+    });
+    buildTypeClass(context, {
+        counter: typeCounters.auth.providers,
+        definitions: context.typesMap.auth.providers,
+        store: components.types.auth.providers,
+        typeClass: 'Auth provider'
+    });
     buildTypeClass(context, {
         counter: typeCounters.blocks,
         definitions: context.typesMap.blocks,

package/dist/build/testSchema.js

@@ -23,12 +23,11 @@ async function testSchema({ components , context  }) {
     });
     if (!valid) {
         await context.logger.warn('Schema not valid.');
-        const promises = errors.map((error)=>context.logger.warn(formatErrorMessage({
+        await Promise.all(errors.map((error)=>context.logger.warn(formatErrorMessage({
                 error,
                 components
             }))
-        );
-        await promises;
+        ));
     }
 }
 export default testSchema;

package/dist/build/updateServerPackageJson.js

@@ -25,6 +25,9 @@ async function updateServerPackageJson({ components , context  }) {
         });
     }
     getPackages(components.types.actions);
+    getPackages(components.types.auth.callbacks);
+    getPackages(components.types.auth.events);
+    getPackages(components.types.auth.providers);
     getPackages(components.types.blocks);
     getPackages(components.types.connections);
     getPackages(components.types.requests);

package/dist/build/validateConfig.js

@@ -13,8 +13,6 @@
   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 = {};
@@ -22,15 +20,6 @@ async function validateConfig({ components  }) {
     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 = {};
     }
@@ -39,19 +28,6 @@ async function validateConfig({ components  }) {
             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/writeAuth.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 writeAuth({ components , context  }) {
+    await context.writeBuildArtifact('auth.json', JSON.stringify(components.auth || {}, null, 2));
+}
+export default writeAuth;

package/dist/build/writePluginImports/generateImportFile.js

@@ -21,13 +21,8 @@ export default {
   {{ import.typeName }},
   {% endfor -%}
 };`;
-function generateImportFile({ types , importPath  }) {
+function generateImportFile({ imports , importPath  }) {
     const templateFn = nunjucksFunction(template);
-    const imports = Object.keys(types).map((typeName)=>({
-            typeName,
-            ...types[typeName]
-        })
-    );
     return templateFn({
         imports,
         importPath