@lowdefy/build 4.0.0-alpha.29 → 4.0.0-alpha.30

package/dist/build/buildRefs/evaluateBuildOperators.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 { NodeParser } from '@lowdefy/operators';
+import operators from '@lowdefy/operators-js/operators/build';
+async function evaluateBuildOperators({ context , input , refDef  }) {
+    const operatorsParser = new NodeParser({
+        env: process.env,
+        operators
+    });
+    const { output , errors  } = operatorsParser.parse({
+        input,
+        location: refDef.path ?? refDef.resolver,
+        operatorPrefix: '_build.'
+    });
+    if (errors.length > 0) {
+        await context.logger.warn('Build operator errors.');
+        const promises = errors.map((error)=>context.logger.warn(error.message));
+        await promises;
+    }
+    return output;
+}
+export default evaluateBuildOperators;

package/dist/build/buildRefs/getConfigFile.js

@@ -0,0 +1,28 @@
+/*
+  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 getConfigFile({ context , refDef , referencedFrom  }) {
+    if (!type.isString(refDef.path)) {
+        throw new Error(`Invalid _ref definition ${JSON.stringify({
+            _ref: refDef.original
+        })} in file ${referencedFrom}`);
+    }
+    const content = await context.readConfigFile(refDef.path);
+    if (content === null) {
+        throw new Error(`Tried to reference file "${refDef.path}" from "${referencedFrom}", but file does not exist.`);
+    }
+    return content;
+}
+export default getConfigFile;

package/dist/build/buildRefs/getRefContent.js

@@ -0,0 +1,44 @@
+/*
+  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 getConfigFile from './getConfigFile.js';
+import parseRefContent from './parseRefContent.js';
+import runRefResolver from './runRefResolver.js';
+async function getRefContent({ context , refDef , referencedFrom  }) {
+    let content;
+    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,
+            referencedFrom
+        });
+    } else {
+        content = await getConfigFile({
+            context,
+            refDef,
+            referencedFrom
+        });
+    }
+    return parseRefContent({
+        content,
+        refDef
+    });
+}
+export default getRefContent;

package/dist/build/buildRefs/getRefPath.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 { type } from '@lowdefy/helpers';
+function getRefPath(refDefinition) {
+    if (type.isObject(refDefinition)) {
+        if (refDefinition.path) {
+            return refDefinition.path;
+        }
+        if (refDefinition._var) {
+            return refDefinition;
+        }
+    }
+    if (type.isString(refDefinition)) {
+        return refDefinition;
+    }
+    return null;
+}
+export default getRefPath;

package/dist/build/buildRefs/getRefsFromFile.js

@@ -0,0 +1,37 @@
+/*
+  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 makeRefDefinition from './makeRefDefinition.js';
+function getRefsFromFile(fileContent) {
+    const foundRefs = [];
+    const reviver = (key, value)=>{
+        if (type.isObject(value)) {
+            if (!type.isUndefined(value._ref)) {
+                const def = makeRefDefinition(value._ref);
+                foundRefs.push(def);
+                return {
+                    _ref: def
+                };
+            }
+        }
+        return value;
+    };
+    const fileContentBuiltRefs = JSON.parse(JSON.stringify(fileContent), reviver);
+    return {
+        foundRefs,
+        fileContentBuiltRefs
+    };
+}
+export default getRefsFromFile;

package/dist/build/buildRefs/getUserJavascriptFunction.js

@@ -0,0 +1,24 @@
+/*
+  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';
+async function getUserJavascriptFunction({ context , filePath  }) {
+    try {
+        return (await import(path.resolve(context.directories.config, filePath))).default;
+    } catch (error) {
+        context.logger.error(`Error importing ${filePath}.`);
+        throw Error(error);
+    }
+}
+export default getUserJavascriptFunction;

package/dist/build/buildRefs/makeRefDefinition.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 { get } from '@lowdefy/helpers';
+import { v1 as uuid } from 'uuid';
+import getRefPath from './getRefPath.js';
+function makeRefDefinition(refDefinition) {
+    return {
+        id: uuid(),
+        original: refDefinition,
+        path: getRefPath(refDefinition),
+        resolver: get(refDefinition, 'resolver'),
+        transformer: get(refDefinition, 'transformer'),
+        vars: get(refDefinition, 'vars', {
+            default: {}
+        })
+    };
+}
+export default makeRefDefinition;

package/dist/build/buildRefs/parseNunjucks.js

@@ -0,0 +1,20 @@
+/*
+  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';
+function parseNunjucks(fileContent, vars) {
+    const template = nunjucksFunction(fileContent);
+    return template(vars);
+}
+export default parseNunjucks;

package/dist/build/buildRefs/parseRefContent.js

@@ -0,0 +1,37 @@
+/*
+  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 { getFileExtension, getFileSubExtension } from '@lowdefy/node-utils';
+import JSON5 from 'json5';
+import YAML from 'yaml';
+import parseNunjucks from './parseNunjucks.js';
+function parseRefContent({ content , refDef  }) {
+    const { path , vars  } = refDef;
+    if (type.isString(path)) {
+        let ext = getFileExtension(path);
+        if (ext === 'njk') {
+            content = parseNunjucks(content, vars);
+            ext = getFileSubExtension(path);
+        }
+        if (ext === 'yaml' || ext === 'yml') {
+            return YAML.parse(content);
+        }
+        if (ext === 'json') {
+            return JSON5.parse(content);
+        }
+    }
+    return content;
+}
+export default parseRefContent;

package/dist/build/buildRefs/populateRefs.js

@@ -0,0 +1,43 @@
+/*
+  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 { get, type } from '@lowdefy/helpers';
+function refReviver(key, value) {
+    if (type.isObject(value)) {
+        if (!type.isUndefined(value._ref)) {
+            return this.parsedFiles[value._ref.id];
+        }
+        if (value._var) {
+            if (type.isString(value._var)) {
+                return JSON.parse(JSON.stringify(get(this.vars, value._var, {
+                    default: null
+                })));
+            }
+            if (type.isObject(value._var) && type.isString(value._var.name)) {
+                return JSON.parse(JSON.stringify(get(this.vars, value._var.name, {
+                    default: type.isNone(value._var.default) ? null : value._var.default
+                })));
+            }
+            throw new Error(`"_var" operator takes a string or object with name field as arguments. Received "${JSON.stringify(value)}"`);
+        }
+    }
+    return value;
+}
+function populateRefs({ parsedFiles , refDef , toPopulate  }) {
+    return JSON.parse(JSON.stringify(toPopulate), refReviver.bind({
+        parsedFiles,
+        vars: refDef.vars
+    }));
+}
+export default populateRefs;

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.
+    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 transformedFile = await runTransformer({
+            context,
+            input: parsedFile,
+            refDef: parsedRefDef
+        });
+        // Evaluated in recursive loop for better error messages
+        const evaluatedOperators = await evaluateBuildOperators({
+            context,
+            input: transformedFile,
+            refDef: parsedRefDef
+        });
+        parsedFiles[newRefDef.id] = evaluatedOperators;
+    }
+    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/buildTypes.js

@@ -0,0 +1,124 @@
+/*
+  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: {},
+        auth: {
+            adapters: {},
+            callbacks: {},
+            events: {},
+            providers: {}
+        },
+        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.auth.adapters,
+        definitions: context.typesMap.auth.adapters,
+        store: components.types.auth.adapters,
+        typeClass: 'Auth adapter'
+    });
+    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,
+        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,32 @@
+/*
+  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';
+function testSchema({ components , context  }) {
+    const { valid , errors  } = validate({
+        schema: lowdefySchema,
+        data: components,
+        returnErrors: true
+    });
+    if (!valid) {
+        context.logger.warn('Schema not valid.');
+        errors.map((error)=>context.logger.warn(formatErrorMessage({
+                error,
+                components
+            })));
+    }
+}
+export default testSchema;