@aeriajs/compiler 0.0.66 → 0.0.68

package/dist/ast.d.ts

@@ -17,6 +17,7 @@ export type ExportSymbol = {
     packageName: string;
     importPath: string;
     symbolName: string;
+    aliasedSymbolName?: string;
 };
 export type NodeBase<TType> = {
     kind: TType;

package/dist/codegen/generateExports.js

@@ -1,4 +1,5 @@
-import { resizeFirstChar, getExtendName, getCollectionId } from './utils.js';
+import { transformSymbolName } from '../utils.js';
+import { getExtendName, getCollectionId } from './utils.js';
 export const generateExports = (ast, options = {
     hasContracts: false,
 }) => {
@@ -6,7 +7,9 @@ export const generateExports = (ast, options = {
         const id = getCollectionId(node.name);
         symbols[id] = {
             id,
-            schema: resizeFirstChar(node.name, true),
+            schema: transformSymbolName(node.name, {
+                capitalize: true,
+            }),
             extend: getExtendName(node.name),
         };
         return symbols;

package/dist/codegen/generateJSCollections.d.ts

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

package/dist/codegen/generateJSCollections.js

@@ -3,7 +3,7 @@ const initialImportedFunctions = [
     'extendCollection',
     'defineCollection',
 ];
-export const generateJSCollections = (ast) => {
+export const generateJSCollections = async (ast) => {
     let javascriptCode = '';
     const importsResult = makeASTImports(ast.collections, {
         [PACKAGE_NAME]: new Set(initialImportedFunctions),
@@ -11,19 +11,36 @@ export const generateJSCollections = (ast) => {
         includeRuntimeOnlyImports: true,
     });
     javascriptCode += importsResult.code.join('\n') + '\n\n';
-    javascriptCode += makeJSCollections(ast, importsResult.modifiedSymbols) + '\n\n';
+    javascriptCode += await makeJSCollections(ast, importsResult.aliasedSymbols) + '\n\n';
     return javascriptCode;
 };
-const makeJSCollections = (ast, modifiedSymbols) => {
+const makeJSFunctions = async (collectionNode) => {
+    let output = '';
+    for (const functionNode of collectionNode.functions) {
+        if (collectionNode.extends) {
+            const module = await import(collectionNode.extends.importPath);
+            const collection = module[collectionNode.extends.symbolName];
+            if (collection.functions && typeof collection.functions[functionNode.name] === 'function') {
+                continue;
+            }
+        }
+        output += functionNode.exportSymbol
+            ? functionNode.exportSymbol.symbolName
+            : `${functionNode.name}: () => { throw new Error('Function not implemented') }`;
+        output += ', ';
+    }
+    return output;
+};
+const makeJSCollections = async (ast, aliasedSymbols) => {
     const collectionCodes = {};
     for (const collectionNode of ast.collections) {
-        const id = getCollectionId(collectionNode.name); // CollectionName -> collectionName
+        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(ast, collectionNode, id)})`
-            : `defineCollection(${makeJSCollectionSchema(ast, collectionNode, id)})`}`;
+            ? `extendCollection(${id in aliasedSymbols
+                ? aliasedSymbols[id]
+                : id}, ${await makeJSCollectionSchema(ast, collectionNode, id)})`
+            : `defineCollection(${await makeJSCollectionSchema(ast, collectionNode, id)})`}`;
         const collectionDeclaration = `export const ${extendCollectionName} = (collection) => extendCollection(${id}, collection)`;
         collectionCodes[collectionNode.name] = [
             '//' + collectionNode.name,
@@ -33,7 +50,7 @@ const makeJSCollections = (ast, modifiedSymbols) => {
     }
     return Object.values(collectionCodes).join('\n\n');
 };
-const makeJSCollectionSchema = (ast, collectionNode, collectionId) => {
+const makeJSCollectionSchema = async (ast, collectionNode, collectionId) => {
     const collectionSchema = {
         item: {},
         description: {
@@ -59,7 +76,7 @@ const makeJSCollectionSchema = (ast, collectionNode, collectionId) => {
                 break;
             case 'functions':
                 collectionSchema.functions = {
-                    [UnquotedSymbol]: `{ ${makeJSFunctions(collectionNode[key])} }`,
+                    [UnquotedSymbol]: `{ ${await makeJSFunctions(collectionNode)} }`,
                 };
                 collectionSchema.exposedFunctions = getExposedFunctions(collectionNode[key]);
                 break;
@@ -96,13 +113,3 @@ const makeJSCollectionSchema = (ast, collectionNode, collectionId) => {
     }
     return stringify(collectionSchema);
 };
-const makeJSFunctions = (functionNodes) => {
-    let output = '';
-    for (const functionNode of functionNodes) {
-        output += functionNode.exportSymbol
-            ? functionNode.exportSymbol.symbolName
-            : `${functionNode.name}: () => { throw new Error('Function not implemented') }`;
-        output += ', ';
-    }
-    return output;
-};

package/dist/codegen/generateTSCollections.d.ts

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

package/dist/codegen/generateTSCollections.js

@@ -1,26 +1,40 @@
-import { unwrapNode, recursivelyUnwrapPropertyNodes, stringify, makeASTImports, resizeFirstChar, getCollectionId, UnquotedSymbol, getExposedFunctions, PACKAGE_NAME } from './utils.js';
+import { transformSymbolName } from '../utils.js';
+import { unwrapNode, recursivelyUnwrapPropertyNodes, stringify, makeASTImports, getCollectionId, UnquotedSymbol, getExposedFunctions, PACKAGE_NAME } from './utils.js';
 const initialImportedTypes = [
     'Collection',
     'SchemaWithId',
     'ExtendCollection',
     'Context',
 ];
-export const generateTSCollections = (ast) => {
+const makeTSFunctions = (collectionNode) => {
+    const funs = {};
+    for (const functionNode of collectionNode.functions) {
+        funs[functionNode.name] = {
+            [UnquotedSymbol]: functionNode.exportSymbol
+                ? `typeof import('${functionNode.exportSymbol.importPath}').${functionNode.exportSymbol.symbolName}`
+                : 'unknown',
+        };
+    }
+    return funs;
+};
+export const generateTSCollections = async (ast) => {
     let code = '';
     code += `import type { ${initialImportedTypes.join(', ')} } from '${PACKAGE_NAME}'\n`; //Used types
     const importsResult = makeASTImports(ast.collections);
     code += importsResult.code.join('\n') + '\n\n';
-    code += makeTSCollections(ast, importsResult.modifiedSymbols) + '\n';
+    code += makeTSCollections(ast, importsResult.aliasedSymbols) + '\n';
     return code;
 };
-const makeTSCollections = (ast, modifiedSymbols) => {
+const makeTSCollections = (ast, aliasedSymbols) => {
     const collectionCodes = {};
     for (const collectionNode of ast.collections) {
-        const id = getCollectionId(collectionNode.name); // CollectionName -> collectionName
-        const schemaName = 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)}>`
+        const id = getCollectionId(collectionNode.name);
+        const schemaName = transformSymbolName(collectionNode.name, {
+            capitalize: true,
+        });
+        const typeName = `${id}Collection`;
+        const collectionType = `export declare type ${typeName} = ${id in aliasedSymbols
+            ? `ExtendCollection<typeof ${aliasedSymbols[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>`;
@@ -67,7 +81,7 @@ const makeTSCollectionSchema = (collectionNode, collectionId) => {
                 };
                 break;
             case 'functions':
-                collectionSchema.functions = makeTSFunctions(collectionNode[key]);
+                collectionSchema.functions = makeTSFunctions(collectionNode);
                 collectionSchema.exposedFunctions = getExposedFunctions(collectionNode[key]);
                 break;
             case 'required':
@@ -103,14 +117,3 @@ const makeTSCollectionSchema = (collectionNode, collectionId) => {
     }
     return stringify(collectionSchema);
 };
-const makeTSFunctions = (functionNodes) => {
-    const funs = {};
-    for (const functionNode of functionNodes) {
-        funs[functionNode.name] = {
-            [UnquotedSymbol]: functionNode.exportSymbol
-                ? `typeof import('${functionNode.exportSymbol.importPath}').${functionNode.exportSymbol.symbolName}`
-                : 'unknown',
-        };
-    }
-    return funs;
-};

package/dist/codegen/utils.d.ts

@@ -14,7 +14,7 @@ export declare const makeASTImports: (ast: AST.Node[], initialImports?: Record<s
     includeRuntimeOnlyImports: boolean;
 }) => {
     code: string[];
-    modifiedSymbols: Record<string, string>;
+    aliasedSymbols: Record<string, string>;
 };
 export declare const unwrapNode: <TNode extends {
     kind: string;
@@ -22,6 +22,5 @@ export declare const unwrapNode: <TNode extends {
 export declare const unwrapPropertyNode: ({ property, nestedProperties, nestedAdditionalProperties }: Pick<AST.PropertyNode, "property" | "nestedProperties" | "nestedAdditionalProperties">) => Property;
 export declare const recursivelyUnwrapPropertyNodes: <TProperties extends Record<string, AST.PropertyNode | AST.PropertyNode[]>, TReturnType = TProperties[keyof TProperties] extends Array<unknown> ? Record<string, Property[]> : Record<string, Property>>(properties: TProperties) => TReturnType;
 export declare const stringify: (value: StringifyProperty, parents?: (symbol | string)[]) => string;
-export declare const resizeFirstChar: (text: string, capitalize: boolean) => string;
 export declare const getCollectionId: (name: string) => string;
 export declare const getExtendName: (name: string) => string;

package/dist/codegen/utils.js

@@ -1,3 +1,4 @@
+import { transformSymbolName } from '../utils.js';
 export const PACKAGE_NAME = 'aeria';
 export const MIDDLEWARES_RUNTIME_PATH = '../../../dist/middlewares/index.js';
 export const UnquotedSymbol = Symbol('unquoted');
@@ -11,14 +12,16 @@ export const getExposedFunctions = (functionNodes) => {
 export const makeASTImports = (ast, initialImports = {}, options = {
     includeRuntimeOnlyImports: false,
 }) => {
-    const modifiedSymbols = {};
+    const aliasedSymbols = {};
     const toImport = ast.reduce((imports, node) => {
         if (node.kind === 'collection') {
             if (node.extends) {
-                const modifiedSymbol = `${node.extends.packageName}${resizeFirstChar(node.extends.symbolName, true)}`;
-                modifiedSymbols[node.extends.symbolName] = modifiedSymbol;
+                const aliasedSymbol = `${node.extends.packageName}${transformSymbolName(node.extends.symbolName, {
+                    capitalize: true,
+                })}`;
+                aliasedSymbols[node.extends.symbolName] = aliasedSymbol;
                 imports[node.extends.importPath] ??= new Set();
-                imports[node.extends.importPath].add(`${node.extends.symbolName} as ${modifiedSymbol}`);
+                imports[node.extends.importPath].add(`${node.extends.symbolName} as ${aliasedSymbol}`);
             }
             if (node.functions) {
                 for (const functionNode of node.functions) {
@@ -42,7 +45,7 @@ export const makeASTImports = (ast, initialImports = {}, options = {
     }, initialImports);
     return {
         code: Object.keys(toImport).map((key) => `import { ${Array.from(toImport[key]).join(', ')} } from '${key}'`),
-        modifiedSymbols,
+        aliasedSymbols,
     };
 };
 export const unwrapNode = (node) => {
@@ -157,11 +160,7 @@ const checkQuotes = (parents, value) => {
     }
     return stringify(value, parents);
 };
-export const resizeFirstChar = (text, capitalize) => {
-    if (capitalize === true) {
-        return text.charAt(0).toUpperCase() + text.slice(1);
-    }
-    return text.charAt(0).toLowerCase() + text.slice(1);
-};
-export const getCollectionId = (name) => resizeFirstChar(name, false);
-export const getExtendName = (name) => `extend${resizeFirstChar(name, true)}Collection`;
+export const getCollectionId = (name) => transformSymbolName(name);
+export const getExtendName = (name) => `extend${transformSymbolName(name, {
+    capitalize: true,
+})}Collection`;

package/dist/codegen.js

@@ -27,8 +27,8 @@ export const generateCode = async (ast, options) => {
     });
     const fileTree = {
         ['collections']: {
-            ['collections.d.ts']: generateTSCollections(ast),
-            ['collections.js']: generateJSCollections(ast),
+            ['collections.d.ts']: await generateTSCollections(ast),
+            ['collections.js']: await generateJSCollections(ast),
             ['index.d.ts']: exports.collections.dts,
             ['index.js']: exports.collections.js,
         },

package/dist/parser.js

@@ -5,7 +5,7 @@ import * as guards from './guards.js';
 import * as lexer from './lexer.js';
 import { TokenType } from './token.js';
 import { Diagnostic } from './diagnostic.js';
-import { DEFAULT_EXPORT_SYMBOLS } from './utils.js';
+import { DEFAULT_EXPORT_SYMBOLS, transformSymbolName } from './utils.js';
 const MAX_ERROR_MESSAGE_ITEMS = 20;
 const ICON_NAMES = icons.map((icon) => icon.name);
 export const locationMap = new WeakMap();
@@ -663,6 +663,9 @@ export const parse = (tokens) => {
                 packageName,
                 importPath: packageName,
                 symbolName: symbolName[0].toLowerCase() + symbolName.slice(1),
+                aliasedSymbolName: `${packageName}${transformSymbolName(symbolName, {
+                    capitalize: true,
+                })}`,
             };
         }
         consume(TokenType.LeftBracket);

package/dist/utils.d.ts

@@ -12,3 +12,6 @@ export declare const DEFAULT_EXPORT_SYMBOLS: {
     unpaginatedGetAll: string;
     upload: string;
 };
+export declare const transformSymbolName: (symbolName: string, options?: {
+    capitalize: boolean;
+}) => string;

package/dist/utils.js

@@ -9,3 +9,11 @@ export const DEFAULT_EXPORT_SYMBOLS = {
     unpaginatedGetAll: 'aeria',
     upload: 'aeria',
 };
+export const transformSymbolName = (symbolName, options = {
+    capitalize: false,
+}) => {
+    if (options.capitalize === true) {
+        return symbolName.charAt(0).toUpperCase() + symbolName.slice(1);
+    }
+    return symbolName.charAt(0).toLowerCase() + symbolName.slice(1);
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aeriajs/compiler",
   "type": "module",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,7 +21,7 @@
     "dist"
   ],
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.159",
+    "@aeriajs/common": "^0.0.160",
     "@aeriajs/types": "^0.0.136"
   },
   "devDependencies": {