@aeriajs/compiler 0.0.3 → 0.0.6

package/dist/ast.d.ts

@@ -0,0 +1,79 @@
+import type { Property, AccessCondition, CollectionActions, SearchOptions, DescriptionPreset, Icon, OwnershipMode } from '@aeriajs/types';
+import type { ArrayProperties } from './utils.js';
+export declare const LOCATION_SYMBOL: unique symbol;
+export declare const PropertyType: {
+    readonly str: "string";
+    readonly int: "integer";
+    readonly num: "number";
+    readonly bool: "boolean";
+    readonly enum: "enum";
+    readonly date: "string";
+    readonly datetime: "string";
+};
+export declare const PropertyModifiers: Record<'Error' | 'Result', ExportSymbol>;
+export type ExportSymbol = {
+    packageName: string;
+    symbolName: string;
+};
+export type NodeBase<TType> = {
+    kind: TType;
+};
+export type PropertyNode = NodeBase<'property'> & {
+    modifier?: keyof typeof PropertyModifiers;
+    property: Property & {
+        [LOCATION_SYMBOL]?: {
+            attributes: Record<string, symbol>;
+            arrays: {
+                [P in ArrayProperties<Extract<Property, {
+                    properties: unknown;
+                }>>]?: symbol[];
+            };
+        };
+    };
+    nestedProperties?: Record<string, PropertyNode>;
+};
+export type CollectionNode = NodeBase<'collection'> & {
+    name: string;
+    extends?: ExportSymbol;
+    owned?: OwnershipMode;
+    icon?: Icon;
+    actions?: CollectionActions;
+    individualActions?: CollectionActions;
+    properties: Record<string, PropertyNode>;
+    functions?: Record<string, {
+        accessCondition: AccessCondition;
+    }>;
+    required?: Record<string, unknown> | string[];
+    indexes?: string[];
+    presets?: DescriptionPreset[];
+    form?: string[];
+    table?: string[];
+    filters?: string[];
+    search?: SearchOptions<any>;
+    [LOCATION_SYMBOL]: {
+        arrays: {
+            [P in ArrayProperties<CollectionNode>]?: symbol[];
+        };
+    };
+};
+export type ContractNode = NodeBase<'contract'> & {
+    name: string;
+    roles?: AccessCondition;
+    query?: PropertyNode;
+    payload?: PropertyNode;
+    response?: PropertyNode | PropertyNode[];
+};
+export type FunctionSetNode = NodeBase<'functionset'> & {
+    name: string;
+    functions: Record<string, {
+        accessCondition: AccessCondition;
+        fromFunctionSet?: true;
+    }>;
+};
+export type ProgramNode = NodeBase<'program'> & {
+    collections: CollectionNode[];
+    contracts: ContractNode[];
+    functionsets: FunctionSetNode[];
+};
+export type Node = CollectionNode | ContractNode | FunctionSetNode;
+export type NoteKind = Node['kind'];

package/dist/ast.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyModifiers = exports.PropertyType = exports.LOCATION_SYMBOL = void 0;
+exports.LOCATION_SYMBOL = Symbol();
+exports.PropertyType = {
+    str: 'string',
+    int: 'integer',
+    num: 'number',
+    bool: 'boolean',
+    enum: 'enum',
+    date: 'string',
+    datetime: 'string',
+};
+exports.PropertyModifiers = {
+    Error: {
+        packageName: 'aeria',
+        symbolName: 'errorSchema',
+    },
+    Result: {
+        packageName: 'aeria',
+        symbolName: 'resultSchema',
+    },
+};

package/dist/ast.mjs

@@ -0,0 +1,21 @@
+"use strict";
+export const LOCATION_SYMBOL = Symbol();
+export const PropertyType = {
+  str: "string",
+  int: "integer",
+  num: "number",
+  bool: "boolean",
+  enum: "enum",
+  date: "string",
+  datetime: "string"
+};
+export const PropertyModifiers = {
+  Error: {
+    packageName: "aeria",
+    symbolName: "errorSchema"
+  },
+  Result: {
+    packageName: "aeria",
+    symbolName: "resultSchema"
+  }
+};

package/dist/codegen/generateContracts.d.ts

@@ -0,0 +1,5 @@
+import type * as AST from '../ast.js';
+export declare const generateContracts: (ast: AST.Node[]) => false | {
+    js: string;
+    dTs: string;
+};

package/dist/codegen/generateContracts.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateContracts = void 0;
+const types_1 = require("@aeriajs/types");
+const utils_js_1 = require("./utils.js");
+const generateContracts = (ast) => {
+    const contractNodes = ast.filter((node) => node.kind === 'contract');
+    if (contractNodes.length === 0) {
+        return false;
+    }
+    return {
+        js: makeJSContractsCode(contractNodes),
+        dTs: makeTSContractsCode(contractNodes),
+    };
+};
+exports.generateContracts = generateContracts;
+const makeJSContractsCode = (contractAst) => {
+    const imports = new Set(['defineContract']);
+    const getCodeForResponse = (responseProperty) => {
+        const { kind, modifier, ...propertyNode } = responseProperty;
+        if (!modifier) {
+            return (0, utils_js_1.stringify)((0, utils_js_1.propertyToSchema)(propertyNode));
+        }
+        const modifierSymbol = responseProperty.modifier === 'Result'
+            ? 'resultSchema'
+            : 'errorSchema';
+        if (!imports.has(modifierSymbol)) {
+            imports.add(modifierSymbol);
+        }
+        return `${modifierSymbol}(${(0, utils_js_1.stringify)((0, utils_js_1.propertyToSchema)(propertyNode))})`;
+    };
+    const declarations = contractAst.map((contractNode) => {
+        const { name, kind, roles, response, ...contractProperty } = contractNode;
+        let responseString = '';
+        if (response) {
+            if (Array.isArray(response)) {
+                const responseArray = [];
+                for (const responseElement of response) {
+                    responseArray.push({
+                        [utils_js_1.UnquotedSymbol]: getCodeForResponse(responseElement),
+                    });
+                }
+                responseString = (0, utils_js_1.stringify)(responseArray);
+            }
+            else {
+                responseString = (0, utils_js_1.stringify)(getCodeForResponse(response));
+            }
+        }
+        const contractSchema = (0, utils_js_1.getProperties)(contractProperty);
+        contractSchema.response = {
+            [utils_js_1.UnquotedSymbol]: responseString,
+        };
+        return `export const ${name}Contract = defineContract(${(0, utils_js_1.stringify)(contractSchema)})`;
+    }).join('\n\n');
+    return `import { ${Array.from(imports).join(', ')} } from \'aeria\'\n\n` + declarations;
+};
+const getResponseSchema = (response) => {
+    const responseSchema = (0, utils_js_1.propertyToSchema)(response);
+    if (!response.modifier) {
+        return responseSchema;
+    }
+    return response.modifier === 'Result' ?
+        (0, types_1.resultSchema)(responseSchema) :
+        (0, types_1.errorSchema)(responseSchema);
+};
+const makeTSContractsCode = (contractAst) => {
+    return contractAst.map((contractNode) => {
+        const { name, kind, roles, ...contractSchema } = contractNode;
+        let responseSchema = null;
+        if (contractSchema.response) {
+            if (Array.isArray(contractSchema.response)) {
+                responseSchema = contractSchema.response.map(getResponseSchema);
+            }
+            else {
+                responseSchema = getResponseSchema(contractSchema.response);
+            }
+        }
+        const contractProperties = (0, utils_js_1.getProperties)(contractSchema);
+        return `export declare const ${contractNode.name}Contract: ${(0, utils_js_1.stringify)({
+            ...contractProperties,
+            response: responseSchema,
+        })}`;
+    }).join('\n\n');
+};

package/dist/codegen/generateContracts.mjs

@@ -0,0 +1,77 @@
+"use strict";
+import { errorSchema, resultSchema } from "@aeriajs/types";
+import { getProperties, propertyToSchema, stringify, UnquotedSymbol } from "./utils.mjs";
+export const generateContracts = (ast) => {
+  const contractNodes = ast.filter((node) => node.kind === "contract");
+  if (contractNodes.length === 0) {
+    return false;
+  }
+  return {
+    js: makeJSContractsCode(contractNodes),
+    dTs: makeTSContractsCode(contractNodes)
+  };
+};
+const makeJSContractsCode = (contractAst) => {
+  const imports = /* @__PURE__ */ new Set(["defineContract"]);
+  const getCodeForResponse = (responseProperty) => {
+    const { kind, modifier, ...propertyNode } = responseProperty;
+    if (!modifier) {
+      return stringify(propertyToSchema(propertyNode));
+    }
+    const modifierSymbol = responseProperty.modifier === "Result" ? "resultSchema" : "errorSchema";
+    if (!imports.has(modifierSymbol)) {
+      imports.add(modifierSymbol);
+    }
+    return `${modifierSymbol}(${stringify(propertyToSchema(propertyNode))})`;
+  };
+  const declarations = contractAst.map((contractNode) => {
+    const { name, kind, roles, response, ...contractProperty } = contractNode;
+    let responseString = "";
+    if (response) {
+      if (Array.isArray(response)) {
+        const responseArray = [];
+        for (const responseElement of response) {
+          responseArray.push({
+            [UnquotedSymbol]: getCodeForResponse(responseElement)
+          });
+        }
+        responseString = stringify(responseArray);
+      } else {
+        responseString = stringify(getCodeForResponse(response));
+      }
+    }
+    const contractSchema = getProperties(contractProperty);
+    contractSchema.response = {
+      [UnquotedSymbol]: responseString
+    };
+    return `export const ${name}Contract = defineContract(${stringify(contractSchema)})`;
+  }).join("\n\n");
+  return `import { ${Array.from(imports).join(", ")} } from 'aeria'
+
+` + declarations;
+};
+const getResponseSchema = (response) => {
+  const responseSchema = propertyToSchema(response);
+  if (!response.modifier) {
+    return responseSchema;
+  }
+  return response.modifier === "Result" ? resultSchema(responseSchema) : errorSchema(responseSchema);
+};
+const makeTSContractsCode = (contractAst) => {
+  return contractAst.map((contractNode) => {
+    const { name, kind, roles, ...contractSchema } = contractNode;
+    let responseSchema = null;
+    if (contractSchema.response) {
+      if (Array.isArray(contractSchema.response)) {
+        responseSchema = contractSchema.response.map(getResponseSchema);
+      } else {
+        responseSchema = getResponseSchema(contractSchema.response);
+      }
+    }
+    const contractProperties = getProperties(contractSchema);
+    return `export declare const ${contractNode.name}Contract: ${stringify({
+      ...contractProperties,
+      response: responseSchema
+    })}`;
+  }).join("\n\n");
+};

package/dist/codegen/generateExports.d.ts

@@ -0,0 +1,15 @@
+import type * as AST from '../ast.js';
+export declare const generateExports: (ast: AST.ProgramNode, hasContracts?: boolean) => {
+    main: {
+        js: string;
+        dTs: string;
+    };
+    collections: {
+        js: string;
+        dTs: string;
+    };
+    contracts?: {
+        js: string;
+        dTs: string;
+    };
+};

package/dist/codegen/generateExports.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExports = void 0;
+const utils_js_1 = require("./utils.js");
+const generateExports = (ast, hasContracts = false) => {
+    const symbolsToExport = Object.values(ast.collections.reduce((symbols, node) => {
+        const id = (0, utils_js_1.getCollectionId)(node.name);
+        symbols[id] = {
+            id,
+            schema: (0, utils_js_1.resizeFirstChar)(node.name, true),
+            extend: (0, utils_js_1.getExtendName)(node.name),
+        };
+        return symbols;
+    }, {}));
+    const exports = {
+        collections: {
+            js: `export { ${symbolsToExport.map((symbol) => `${symbol.id}`).join(', ')} } from './collections.js'`,
+            dTs: `export { ${symbolsToExport.map((symbol) => `${symbol.id}`).join(', ')} } from './collections.js'`,
+        },
+        main: {
+            js: (hasContracts
+                ? 'export * as contracts from \'./contracts/index.js\'\n'
+                : '') +
+                'export * as collections from \'./collections/index.js\'\n' +
+                `export { ${symbolsToExport.map((symbol) => symbol.extend).join(', ')} } from './collections/collections.js'`,
+            dTs: (hasContracts
+                ? 'export * as contracts from \'./contracts/index.js\'\n'
+                : '') +
+                'export * as collections from \'./collections/index.js\'\n' +
+                `export { ${symbolsToExport.map((symbol) => `${symbol.extend}, ${symbol.schema}`).join(', ')} } from './collections/collections.js'`,
+        },
+    };
+    if (hasContracts) {
+        exports.contracts = {
+            js: 'export * from \'./contracts.js\'',
+            dTs: 'export * from \'./contracts.js\'',
+        };
+    }
+    return exports;
+};
+exports.generateExports = generateExports;

package/dist/codegen/generateExports.mjs

@@ -0,0 +1,32 @@
+"use strict";
+import { resizeFirstChar, getExtendName, getCollectionId } from "./utils.mjs";
+export const generateExports = (ast, hasContracts = false) => {
+  const symbolsToExport = Object.values(ast.collections.reduce((symbols, node) => {
+    const id = getCollectionId(node.name);
+    symbols[id] = {
+      id,
+      schema: resizeFirstChar(node.name, true),
+      extend: getExtendName(node.name)
+    };
+    return symbols;
+  }, {}));
+  const exports = {
+    collections: {
+      js: `export { ${symbolsToExport.map((symbol) => `${symbol.id}`).join(", ")} } from './collections.mjs'`,
+      dTs: `export { ${symbolsToExport.map((symbol) => `${symbol.id}`).join(", ")} } from './collections.mjs'`
+    },
+    main: {
+      js: (hasContracts ? "export * as contracts from './contracts/index.mjs'\n" : "") + `export * as collections from './collections/index.mjs'
+export { ${symbolsToExport.map((symbol) => symbol.extend).join(", ")} } from './collections/collections.mjs'`,
+      dTs: (hasContracts ? "export * as contracts from './contracts/index.mjs'\n" : "") + `export * as collections from './collections/index.mjs'
+export { ${symbolsToExport.map((symbol) => `${symbol.extend}, ${symbol.schema}`).join(", ")} } from './collections/collections.mjs'`
+    }
+  };
+  if (hasContracts) {
+    exports.contracts = {
+      js: "export * from './contracts.mjs'",
+      dTs: "export * from './contracts.mjs'"
+    };
+  }
+  return exports;
+};

package/dist/codegen/generateJSCollections.d.ts

@@ -0,0 +1,2 @@
+import type * as AST from '../ast.js';
+export declare const generateJSCollections: (ast: AST.CollectionNode[]) => string;

package/dist/codegen/generateJSCollections.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJSCollections = void 0;
+const utils_js_1 = require("./utils.js");
+const initialImportedFunctions = [
+    'extendCollection',
+    'defineCollection',
+];
+const generateJSCollections = (ast) => {
+    let javascriptCode = '';
+    const importsResult = (0, utils_js_1.makeASTImports)(ast, {
+        [utils_js_1.aeriaPackageName]: new Set(initialImportedFunctions),
+    });
+    javascriptCode += importsResult.code + '\n\n';
+    javascriptCode += makeJSCollections(ast, importsResult.modifiedSymbols) + '\n\n';
+    return javascriptCode;
+};
+exports.generateJSCollections = generateJSCollections;
+const makeJSCollections = (ast, modifiedSymbols) => {
+    const collectionCodes = {};
+    for (const collectionNode of ast) {
+        const id = (0, utils_js_1.getCollectionId)(collectionNode.name); // CollectionName -> collectionName
+        const extendCollectionName = (0, utils_js_1.getExtendName)(collectionNode.name);
+        const collectionDefinition = `export const ${id} = ${collectionNode.extends
+            ? `extendCollection(${id in modifiedSymbols
+                ? modifiedSymbols[id]
+                : id}, ${makeJSCollectionSchema(collectionNode, id)})`
+            : `defineCollection(${makeJSCollectionSchema(collectionNode, id)})`}`;
+        const collectionDeclaration = `export const ${extendCollectionName} = (collection) => extendCollection(${id}, collection)`;
+        collectionCodes[collectionNode.name] = [
+            '//' + collectionNode.name,
+            collectionDefinition,
+            collectionDeclaration,
+        ].join('\n');
+    }
+    return Object.values(collectionCodes).join('\n\n');
+};
+const makeJSCollectionSchema = (collectionNode, collectionId) => {
+    const collectionSchema = {
+        description: {
+            $id: collectionId,
+        },
+    };
+    for (const key of Object.keys(collectionNode)) {
+        if (collectionNode[key] === undefined) {
+            continue;
+        }
+        switch (key) {
+            case 'properties':
+                collectionSchema.description.properties = (0, utils_js_1.getProperties)(collectionNode[key]);
+                break;
+            case 'owned':
+                collectionSchema.description.owned = collectionNode[key];
+                break;
+            case 'functions':
+                collectionSchema.functions = {
+                    [utils_js_1.UnquotedSymbol]: `{ ${makeJSFunctions(collectionNode[key])} }`,
+                };
+                collectionSchema.exposedFunctions = (0, utils_js_1.getExposedFunctions)(collectionNode[key]);
+                break;
+            case 'table':
+            case 'filters':
+            case 'indexes':
+            case 'form':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'actions':
+            case 'individualActions':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'icon':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'presets':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'search':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'required':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+        }
+    }
+    return (0, utils_js_1.stringify)(collectionSchema);
+};
+const makeJSFunctions = (functions) => {
+    return Object.entries(functions).map(([key, _value]) => utils_js_1.defaultFunctions.includes(key)
+        ? key
+        : `${key}: () => { throw new Error('Function not implemented') }`).join(', ');
+};

package/dist/codegen/generateJSCollections.mjs

@@ -0,0 +1,82 @@
+"use strict";
+import { makeASTImports, getProperties, stringify, aeriaPackageName, getExtendName, getCollectionId, UnquotedSymbol, defaultFunctions, getExposedFunctions } from "./utils.mjs";
+const initialImportedFunctions = [
+  "extendCollection",
+  "defineCollection"
+];
+export const generateJSCollections = (ast) => {
+  let javascriptCode = "";
+  const importsResult = makeASTImports(ast, {
+    [aeriaPackageName]: new Set(initialImportedFunctions)
+  });
+  javascriptCode += importsResult.code + "\n\n";
+  javascriptCode += makeJSCollections(ast, importsResult.modifiedSymbols) + "\n\n";
+  return javascriptCode;
+};
+const makeJSCollections = (ast, modifiedSymbols) => {
+  const collectionCodes = {};
+  for (const collectionNode of ast) {
+    const id = getCollectionId(collectionNode.name);
+    const extendCollectionName = getExtendName(collectionNode.name);
+    const collectionDefinition = `export const ${id} = ${collectionNode.extends ? `extendCollection(${id in modifiedSymbols ? modifiedSymbols[id] : id}, ${makeJSCollectionSchema(collectionNode, id)})` : `defineCollection(${makeJSCollectionSchema(collectionNode, id)})`}`;
+    const collectionDeclaration = `export const ${extendCollectionName} = (collection) => extendCollection(${id}, collection)`;
+    collectionCodes[collectionNode.name] = [
+      "//" + collectionNode.name,
+      collectionDefinition,
+      collectionDeclaration
+    ].join("\n");
+  }
+  return Object.values(collectionCodes).join("\n\n");
+};
+const makeJSCollectionSchema = (collectionNode, collectionId) => {
+  const collectionSchema = {
+    description: {
+      $id: collectionId
+    }
+  };
+  for (const key of Object.keys(collectionNode)) {
+    if (collectionNode[key] === void 0) {
+      continue;
+    }
+    switch (key) {
+      case "properties":
+        collectionSchema.description.properties = getProperties(collectionNode[key]);
+        break;
+      case "owned":
+        collectionSchema.description.owned = collectionNode[key];
+        break;
+      case "functions":
+        collectionSchema.functions = {
+          [UnquotedSymbol]: `{ ${makeJSFunctions(collectionNode[key])} }`
+        };
+        collectionSchema.exposedFunctions = getExposedFunctions(collectionNode[key]);
+        break;
+      case "table":
+      case "filters":
+      case "indexes":
+      case "form":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "actions":
+      case "individualActions":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "icon":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "presets":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "search":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "required":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+    }
+  }
+  return stringify(collectionSchema);
+};
+const makeJSFunctions = (functions) => {
+  return Object.entries(functions).map(([key, _value]) => defaultFunctions.includes(key) ? key : `${key}: () => { throw new Error('Function not implemented') }`).join(", ");
+};

package/dist/codegen/generateTSCollections.d.ts

@@ -0,0 +1,2 @@
+import type * as AST from '../ast.js';
+export declare const generateTSCollections: (ast: AST.CollectionNode[]) => string;

package/dist/codegen/generateTSCollections.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTSCollections = void 0;
+const utils_js_1 = require("./utils.js");
+const initialImportedTypes = [
+    'Collection',
+    'SchemaWithId',
+    'ExtendCollection',
+    'Context',
+];
+const generateTSCollections = (ast) => {
+    let code = '';
+    code += `import type { ${initialImportedTypes.join(', ')} } from '${utils_js_1.aeriaPackageName}'\n`; //Used types
+    const importsResult = (0, utils_js_1.makeASTImports)(ast);
+    code += importsResult.code + '\n\n';
+    code += makeTSCollections(ast, importsResult.modifiedSymbols) + '\n';
+    return code;
+};
+exports.generateTSCollections = generateTSCollections;
+/** Creates the code exporting the collection type, declaration, schema and extend for each collection and returns them in a string */
+const makeTSCollections = (ast, modifiedSymbols) => {
+    const collectionCodes = {};
+    for (const collectionNode of ast) {
+        const id = (0, utils_js_1.getCollectionId)(collectionNode.name); // CollectionName -> collectionName
+        const schemaName = (0, utils_js_1.resizeFirstChar)(collectionNode.name, true); // collectionName -> CollectionName
+        const typeName = id + 'Collection'; // Pet -> petCollection
+        const collectionType = `export declare type ${typeName} = ${id in modifiedSymbols
+            ? `ExtendCollection<typeof ${modifiedSymbols[id]}, ${makeTSCollectionSchema(collectionNode, id)}>`
+            : makeTSCollectionSchema(collectionNode, id)}`;
+        const collectionDeclaration = `export declare const ${id}: ${typeName} & { item: SchemaWithId<${typeName}["description"]> }`;
+        const collectionSchema = `export declare type ${schemaName} = SchemaWithId<typeof ${id}.description>`;
+        const collectionExtend = `export declare const extend${schemaName}Collection: <
+            const TCollection extends {
+              [P in Exclude<keyof Collection, "functions">]?: Partial<Collection[P]>
+            } & {
+              functions?: {
+                [F: string]: (payload: any, context: Context<typeof ${id}["description"]>) => unknown
+              }
+            }>(collection: TCollection) => ExtendCollection<typeof ${id}, TCollection>`;
+        collectionCodes[collectionNode.name] = [
+            '//' + collectionNode.name,
+            collectionType,
+            collectionDeclaration,
+            collectionSchema,
+            collectionExtend,
+        ].join('\n');
+    }
+    return Object.values(collectionCodes).join('\n\n');
+};
+const makeTSCollectionSchema = (collectionNode, collectionId) => {
+    const collectionSchema = {
+        description: {
+            $id: collectionId,
+        },
+    };
+    for (const key of Object.keys(collectionNode)) {
+        if (collectionNode[key] === undefined) {
+            continue;
+        }
+        switch (key) {
+            case 'properties':
+                collectionSchema.description.properties = (0, utils_js_1.getProperties)(collectionNode[key]);
+                break;
+            case 'owned':
+                collectionSchema.description.owned = collectionNode[key];
+                break;
+            case 'functions':
+                collectionSchema.functions = makeTSFunctions(collectionNode[key]);
+                collectionSchema.exposedFunctions = (0, utils_js_1.getExposedFunctions)(collectionNode[key]);
+                break;
+            case 'table':
+            case 'filters':
+            case 'indexes':
+            case 'form':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'actions':
+            case 'individualActions':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'icon':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'presets':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'search':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'required':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+        }
+    }
+    return (0, utils_js_1.stringify)(collectionSchema);
+};
+/** Turns each function to 'typeof functioName' if it's from aeria or not */
+const makeTSFunctions = (functions) => {
+    return Object.keys(functions).reduce((acc, key) => {
+        acc[key] = {
+            [utils_js_1.UnquotedSymbol]: utils_js_1.defaultFunctions.includes(key)
+                ? `typeof ${key}`
+                : '() => never',
+        };
+        return acc;
+    }, {});
+};