okai 0.0.24 → 0.0.25

package/dist/ts-once.js

@@ -0,0 +1,240 @@
+import { pick, toCamelCase, toPascalCase } from "./utils.js";
+// Tranforms that are only applied once on AI TypeScript AST
+export function createTdAstFromAIAst(tsAst) {
+    mergeInterfacesAndClasses(tsAst);
+    rewriteToPascalCase(tsAst);
+    replaceReferences(tsAst);
+    replaceIds(tsAst);
+    tsAst.classes.forEach(cls => {
+        // replaceUserRefs(cls)
+        rewriteDuplicateTypePropNames(cls);
+        rewriteSelfReferencingIds(cls);
+    });
+    changeUserRefsToAuditBase(tsAst);
+    return tsAst;
+}
+/*
+function replaceUserRefs(type:ParsedClass) {
+    type.name = toPascalCase(type.name)
+    type.properties?.forEach(prop => {
+        prop.name = toCamelCase(prop.name)
+        if (prop.type === 'User' || prop.name === 'userId') {
+            type.extends = 'AuditBase'
+        }
+
+        if (prop.type.startsWith('Array<')) {
+            const elType = prop.type.slice('Array<'.length, -1)
+            prop.type = elType + '[]'
+        }
+        if (prop.type === 'User') {
+            prop.name = 'userId'
+            prop.type = 'string'
+        }
+        if (prop.type === 'User[]') {
+            if (prop.name.endsWith('s')) {
+                prop.name = prop.name.slice(0, -1) + 'Ids'
+            }
+            prop.type = 'string[]'
+        }
+    })
+}
+*/
+// Replace User Tables and FKs with AuditBase tables and 
+export function transformUserRefs(tsAst, info) {
+    const addClasses = [];
+    for (const cls of tsAst.classes) {
+        const removeProps = [];
+        for (const prop of cls.properties) {
+            const propLower = prop.name.toLowerCase();
+            if (propLower === 'userid') {
+                removeProps.push(prop.name);
+            }
+            if (prop.type === 'User') {
+                cls.extends = 'AuditBase';
+                // Replace with local User Type
+                /*
+                [Reference(SelfId = nameof(CreatedBy), RefId = nameof(User.UserName), RefLabel = nameof(User.DisplayName))]
+                public User UserRef { get; set; }
+                */
+                if (info.userType)
+                    prop.type = info.userType;
+                if (!prop.annotations)
+                    prop.annotations = [];
+                const attr = {
+                    name: 'reference',
+                    args: {
+                        selfId: 'createdBy',
+                        refId: 'userName',
+                    }
+                };
+                if (info.userLabel)
+                    attr.args.refLabel = info.userLabel;
+                prop.annotations.push(attr);
+            }
+            if (prop.type === 'User[]') {
+                if (info.userType) {
+                    prop.type = info.userType + '[]';
+                    if (!prop.annotations)
+                        prop.annotations = [];
+                    prop.annotations.push({ name: 'reference' });
+                    const idPropType = cls.properties.find(x => x.name.toLowerCase() === 'id')?.type ?? 'number';
+                    // Add Many to Many User Table
+                    addClasses.push({
+                        name: cls.name + 'User',
+                        properties: [
+                            { name: 'id', type: 'number' },
+                            { name: toCamelCase(cls.name) + 'Id', type: idPropType },
+                            { name: toCamelCase(info.userType) + 'Id', type: info.userIdType ?? 'string' },
+                        ]
+                    });
+                }
+            }
+        }
+        if (removeProps.length) {
+            cls.extends = 'AuditBase';
+            cls.properties = cls.properties.filter(x => !removeProps.includes(x.name));
+        }
+    }
+    if (addClasses.length) {
+        tsAst.classes.push(...addClasses);
+    }
+    // Remove User Table if local User Table exists
+    if (info.userType) {
+        tsAst.classes = tsAst.classes.filter(x => x.name !== 'User');
+    }
+}
+function rewriteDuplicateTypePropNames(type) {
+    const duplicateTypePropMap = {
+        note: 'content',
+    };
+    const duplicateProp = type.properties?.find(x => toPascalCase(x.name) === type.name);
+    if (duplicateProp) {
+        const newName = duplicateTypePropMap[duplicateProp.name] ?? 'value';
+        duplicateProp.name = newName;
+    }
+}
+function rewriteSelfReferencingIds(type) {
+    const selfRefId = type.properties?.find(x => x.name.toLowerCase() === `${type.name}id`.toLowerCase());
+    if (selfRefId) {
+        selfRefId.name = `parentId`;
+    }
+}
+function rewriteToPascalCase(ast) {
+    ast?.classes.forEach(t => {
+        t.name = toPascalCase(t.name);
+        t.properties?.forEach(p => p.name = toCamelCase(p.name));
+    });
+    ast.enums?.forEach(e => {
+        e.name = toPascalCase(e.name);
+        e.members?.forEach(m => {
+            m.name = toPascalCase(m.name);
+        });
+    });
+}
+function changeUserRefsToAuditBase(ast) {
+    const user = ast.classes?.find(x => x.name === 'User') ?? ast.interfaces?.find(x => x.name === 'User');
+    if (user) {
+        user.properties?.forEach(prop => {
+            // If User Model references any other model, chnage it to extend AuditBase
+            const ref = ast.classes?.find(x => x.name === prop.type)
+                ?? ast.interfaces?.find(x => x.name === prop.type);
+            if (ref) {
+                ref.extends = 'AuditBase';
+            }
+            // If User Model references any other model[], chnage it to extend AuditBase
+            const refs = ast.classes?.find(x => prop.type.endsWith('[]') && x.name === prop.type.substring(0, prop.type.length - 2))
+                ?? ast.interfaces?.find(x => prop.type.endsWith('[]') && x.name === prop.type.substring(0, prop.type.length - 2));
+            if (refs) {
+                refs.extends = 'AuditBase';
+            }
+        });
+    }
+}
+function mergeInterfacesAndClasses(ast) {
+    const classes = [];
+    for (const iface of ast.interfaces) {
+        const cls = interfaceToClass(iface);
+        classes.push(cls);
+    }
+    for (const cls of ast.classes) {
+        classes.push(cls);
+    }
+    ast.classes = classes;
+    ast.interfaces = [];
+}
+function interfaceToClass(ast) {
+    return pick(ast, ['name', 'extends', 'comment', 'properties', 'annotations']);
+}
+export function replaceReferences(tsAst) {
+    const references = [
+        'Service',
+    ];
+    // The most important types are the ones with the most references
+    const refCount = (t) => t.properties?.filter(p => tsAst.classes.find(x => x.name === p.type)).length || 0;
+    const importantTypes = tsAst.classes.sort((x, y) => refCount(y) - refCount(x));
+    for (const cls of tsAst.classes) {
+        if (references.includes(cls.name)) {
+            const importantType = importantTypes.find(x => x.properties?.some(p => p.type === cls.name));
+            if (importantType) {
+                const newName = `${importantType.name}${cls.name}`;
+                replaceReference(tsAst, cls.name, newName);
+            }
+        }
+    }
+}
+export function replaceReference(gen, fromType, toType) {
+    for (const cls of gen.classes) {
+        if (cls.name === fromType) {
+            cls.name = toType;
+        }
+        if (cls.properties) {
+            for (const prop of cls.properties) {
+                if (prop.type === fromType) {
+                    prop.type = toType;
+                }
+                if (prop.type === `${fromType}[]`) {
+                    prop.type = `${toType}[]`;
+                }
+                2;
+                if (prop.name === fromType) {
+                    prop.name = toType;
+                }
+                if (prop.name === `${fromType}Id`) {
+                    prop.name = `${toType}Id`;
+                }
+            }
+        }
+    }
+}
+export function replaceIds(gen) {
+    for (const type of gen.classes) {
+        const explicitIdProp = type.properties?.find(x => x.name.toLowerCase() === `${type.name}Id`.toLowerCase());
+        if (explicitIdProp) {
+            const hasId = type.properties.find(x => x.name === 'id');
+            if (hasId) {
+                explicitIdProp.name = 'parentId';
+                explicitIdProp.optional = true;
+            }
+            else {
+                explicitIdProp.name = 'id';
+            }
+        }
+        else {
+            // If using a shortened id for the type e.g. (PerformanceReview, ReviewId)
+            const firstProp = type.properties?.[0];
+            if (firstProp?.name.endsWith('Id') && type.name.toLowerCase().includes(firstProp.name.substring(0, firstProp.name.length - 2).toLowerCase())) {
+                firstProp.name = 'id';
+            }
+        }
+    }
+    // Replace all string Ids with int Ids
+    const anyIntPks = gen.classes.some(x => x.properties?.some(p => p.name === 'id' && p.type === 'number'));
+    if (!anyIntPks) {
+        for (const type of gen.classes) {
+            const idProp = type.properties?.find(x => x.name === 'id');
+            if (idProp) {
+                idProp.type = 'number';
+            }
+        }
+    }
+}

package/dist/ts-parser.js

@@ -1,15 +1,20 @@
+import { lastLeftPart, leftPart, rightPart } from "./utils.js";
 export class TypeScriptParser {
     static CLASS_PATTERN = /class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?\s*{/g;
     static INTERFACE_PATTERN = /interface\s+(\w+)(?:\s+extends\s+(\w+))?\s*{/g;
     static ENUM_PATTERN = /enum\s+(\w+)\s*{([^}]*)}/g;
     static PROPERTY_PATTERN = /(?:(?<modifier>private|public|protected|readonly)\s+)*(?<name>\w+)(?<optional>\?)?\s*:\s*(?<type>[\w<>[\],\s]+)(?<union>\|\s*[\w<>[\],|,\s]+)?\s*;?/;
     static ENUM_MEMBER_PATTERN = /(\w+)\s*(?:=\s*("[^"]*"|'[^']*'|\d+|[^,\n]+))?\s*/;
-    // private static readonly ANNOTATION_PATTERN = /@(\w+\.?\w*)\s*\((.*)\)/
-    static ANNOTATION_PATTERN = /@([A-Za-z_][A-Za-z0-9_]*\.?[A-Za-z_]?[A-Za-z0-9_]*)\s*\((.*)\)/;
+    static ANNOTATION_PATTERN = /^\s*@([A-Za-z_][A-Za-z0-9_]*\.?[A-Za-z_]?[A-Za-z0-9_]*)/;
+    static REFERENCE_PATTERN = /\/\/\/\s*<reference\s+path="([^"]+)"\s*\/>/g;
     classes = [];
     interfaces = [];
     enums = [];
+    references = [];
     getLineComment(line) {
+        if (line.match(TypeScriptParser.REFERENCE_PATTERN)) {
+            return undefined;
+        }
         // Check for single line comment at end of line
         const singleLineMatch = line.match(/.*?\/\/\s*(.+)$/);
         if (singleLineMatch) {
@@ -27,7 +32,8 @@ export class TypeScriptParser {
         const lineNumber = beforePosition.split('\n').length;
         if (lineNumber > 0) {
             const lines = content.split('\n');
-            return lines[lineNumber - 2]; // -2 because array is 0-based and we want previous line
+            const ret = lines[lineNumber - 2]; // -2 because array is 0-based and we want previous line
+            return ret;
         }
         return undefined;
     }
@@ -39,36 +45,19 @@ export class TypeScriptParser {
         while (previousLine && (!previousLine.match(TypeScriptParser.PROPERTY_PATTERN) || previousLine.match(ANNOTATION))) {
             const annotation = previousLine.match(ANNOTATION) ? parseAnnotation(previousLine) : undefined;
             if (annotation) {
-                if (previousLine.trimStart().startsWith('//')) {
-                    annotation.comment = true;
-                }
                 annotations.push(annotation);
             }
             else {
-                const comment = this.getLineComment(previousLine);
+                const comment = this.isComment(previousLine) ? this.getLineComment(previousLine) : null;
                 if (comment) {
-                    const annotation = comment.match(ANNOTATION) ? parseAnnotation(comment) : undefined;
-                    if (annotation) {
-                        annotation.comment = true;
-                        annotations.push(annotation);
-                    }
-                    else {
-                        commments.unshift(comment);
-                    }
+                    commments.unshift(comment);
                 }
             }
             previousLine = this.getPreviousLine(body, body.indexOf(previousLine));
         }
         const lineComment = this.getLineComment(line);
         if (lineComment) {
-            const annotation = lineComment.match(ANNOTATION) ? parseAnnotation(lineComment) : undefined;
-            if (annotation) {
-                annotation.comment = true;
-                annotations.push(annotation);
-            }
-            else {
-                commments.push(lineComment);
-            }
+            commments.push(lineComment);
         }
         else if (line.match(ANNOTATION)) {
             const annotation = parseAnnotation(line);
@@ -190,6 +179,12 @@ export class TypeScriptParser {
             this.classes.push(cls);
         }
     }
+    parseReferences(content) {
+        let match;
+        while ((match = TypeScriptParser.REFERENCE_PATTERN.exec(content))) {
+            this.references.push({ path: match[1] });
+        }
+    }
     parseEnumMembers(enumBody) {
         const members = [];
         const lines = enumBody.split('\n')
@@ -215,7 +210,7 @@ export class TypeScriptParser {
                     prevIntValue = member.value;
                 }
                 const previousLine = this.getPreviousLine(enumBody, enumBody.indexOf(line));
-                if (previousLine) {
+                if (previousLine && this.isComment(previousLine)) {
                     member.comment = this.getLineComment(previousLine);
                 }
                 const lineComment = this.getLineComment(line);
@@ -227,6 +222,12 @@ export class TypeScriptParser {
         });
         return members;
     }
+    isComment(s) {
+        if (!s)
+            return false;
+        s = s.trim();
+        return s.startsWith('//') || s.startsWith('/*');
+    }
     parseEnums(content) {
         let match;
         while ((match = TypeScriptParser.ENUM_PATTERN.exec(content))) {
@@ -249,10 +250,12 @@ export class TypeScriptParser {
         this.classes = [];
         this.interfaces = [];
         this.enums = [];
+        this.parseReferences(sourceCode);
         this.parseInterfaces(sourceCode);
         this.parseClasses(sourceCode);
         this.parseEnums(sourceCode);
         return {
+            references: this.references,
             classes: this.classes,
             interfaces: this.interfaces,
             enums: this.enums
@@ -260,12 +263,18 @@ export class TypeScriptParser {
     }
 }
 export function parseAnnotation(annotation) {
-    // Match @name and everything inside ()
-    const regex = /@(\w+\.?\w*)\s*\((.*)\)/;
+    const regex = TypeScriptParser.ANNOTATION_PATTERN;
+    if (annotation.includes('//')) {
+        annotation = leftPart(annotation, '//');
+    }
     const match = annotation.match(regex);
     if (!match)
         return null;
-    const [, name, paramsStr] = match;
+    const [, name] = match;
+    // Extract parameters if they exist
+    const paramsStr = annotation.includes('(') && annotation.includes(')')
+        ? lastLeftPart(rightPart(annotation, '('), ')')
+        : '';
     try {
         // Handle multiple arguments by splitting on commas outside quotes/braces
         const rawArgs = splitArgs(paramsStr);

package/dist/tsd-gen.js

@@ -1,35 +1,24 @@
-import { toPascalCase, toCamelCase } from "./utils.js";
 export class TsdGenerator {
     interfaces = [];
     enums = [];
-    ast = { classes: [], interfaces: [], enums: [] };
-    clsToInterface(ast) {
-        const to = {
-            name: ast.name,
-            extends: ast.extends,
-            comment: ast.comment,
-            properties: ast.properties,
-            annotations: ast.annotations,
-        };
-        return to;
-    }
+    ast = { references: [], classes: [], interfaces: [], enums: [] };
     attrValue(type, value) {
         return type === 'string' ? `"${value}"` : value;
     }
     toAttr(attr) {
-        const sbArgs = [];
+        const sbCtorArgs = [];
         if (attr?.constructorArgs?.length) {
             for (const arg of attr.constructorArgs) {
-                sbArgs.push(this.attrValue(typeof arg, arg));
+                sbCtorArgs.push(this.attrValue(typeof arg, arg));
             }
         }
+        const sbArgs = [];
         if (attr.args) {
             for (const [name, value] of Object.entries(attr.args)) {
-                sbArgs.push(`${name}=${this.attrValue(typeof value, value)}`);
+                sbArgs.push(`${name}:${this.attrValue(typeof value, value)}`);
             }
         }
-        const prefix = attr.comment ? '// ' : '';
-        return `${prefix}@${attr.name}(${sbArgs.join(',')})`;
+        return `@${attr.name}(${sbCtorArgs.join(',')}${sbCtorArgs.length && sbArgs.length ? ',' : ''}${sbArgs.length ? `{${sbArgs.join(',')}}` : ''})`;
     }
     toInterface(ast) {
         return this.toType(ast, 'interface');
@@ -82,84 +71,32 @@ export class TsdGenerator {
         sb.push('}');
         return sb.join('\n');
     }
-    generate(ast, type = 'interface') {
+    generate(ast) {
         this.ast = ast;
         const sb = [];
+        if (ast.references?.length) {
+            for (const ref of ast.references) {
+                sb.push(`/// <reference path="${ref.path}" />`);
+            }
+            sb.push('');
+        }
         for (const cls of ast.enums ?? []) {
             sb.push(this.toEnum(cls));
             sb.push('');
         }
         for (const cls of ast.interfaces ?? []) {
-            sb.push(this.toType(cls, type));
+            sb.push(this.toType(cls, "interface"));
             sb.push('');
         }
         for (const cls of ast.classes ?? []) {
-            const iface = this.clsToInterface(cls);
-            sb.push(this.toType(iface, type));
+            sb.push(this.toType(cls, "class"));
             sb.push('');
         }
         const tsd = sb.join('\n');
         return tsd;
     }
 }
-export class TsdDataModelGenerator extends TsdGenerator {
-    duplicateTypePropMap = {
-        note: 'content',
-    };
-    convertType(type) {
-        type.name = toPascalCase(type.name);
-        type.properties?.forEach(prop => {
-            prop.name = toCamelCase(prop.name);
-            if (prop.type.startsWith('Array<')) {
-                const elType = prop.type.slice('Array<'.length, -1);
-                prop.type = elType + '[]';
-            }
-            if (prop.type === 'User') {
-                prop.name = 'userId';
-                prop.type = 'string';
-            }
-            if (prop.type === 'User[]') {
-                if (prop.name.endsWith('s')) {
-                    prop.name = prop.name.slice(0, -1) + 'Ids';
-                }
-                prop.type = 'string[]';
-            }
-        });
-        this.rewriteDuplicateTypePropNames(type);
-        this.rewriteSelfReferencingIds(type);
-    }
-    rewriteDuplicateTypePropNames(type) {
-        const duplicateProp = type.properties?.find(x => toPascalCase(x.name) === type.name);
-        if (duplicateProp) {
-            const newName = this.duplicateTypePropMap[duplicateProp.name] ?? 'value';
-            duplicateProp.name = newName;
-        }
-    }
-    rewriteSelfReferencingIds(type) {
-        const selfRefId = type.properties?.find(x => x.name.toLowerCase() === `${type.name}id`.toLowerCase());
-        if (selfRefId) {
-            selfRefId.name = `parentId`;
-        }
-    }
-    generate(ast) {
-        ast.classes?.forEach(cls => {
-            this.convertType(cls);
-        });
-        ast.interfaces?.forEach(cls => {
-            this.convertType(cls);
-        });
-        ast.enums?.forEach(e => {
-            e.name = toPascalCase(e.name);
-            e.members?.forEach(m => {
-                m.name = toPascalCase(m.name);
-            });
-        });
-        if (ast.classes) {
-            ast.classes = ast.classes.filter(x => x.name !== 'User');
-        }
-        if (ast.interfaces) {
-            ast.interfaces = ast.interfaces.filter(x => x.name !== 'User');
-        }
-        return super.generate(ast, "class");
-    }
+export function toTsd(tsAst) {
+    const gen = new TsdGenerator();
+    return gen.generate(tsAst);
 }

package/dist/utils.js

@@ -121,9 +121,34 @@ export function rightPart(s, needle) {
         ? s
         : s.substring(pos + needle.length);
 }
+export function lastLeftPart(s, needle) {
+    if (s == null)
+        return null;
+    let pos = s.lastIndexOf(needle);
+    return pos == -1
+        ? s
+        : s.substring(0, pos);
+}
+export function lastRightPart(s, needle) {
+    if (s == null)
+        return null;
+    let pos = s.lastIndexOf(needle);
+    return pos == -1
+        ? s
+        : s.substring(pos + needle.length);
+}
 export function splitCase(t) {
     return typeof t != 'string' ? t : t.replace(/([A-Z]|[0-9]+)/g, ' $1').replace(/_/g, ' ').trim();
 }
+export function pick(o, keys) {
+    const to = {};
+    Object.keys(o).forEach(k => {
+        if (keys.indexOf(k) >= 0) {
+            to[k] = o[k];
+        }
+    });
+    return to;
+}
 export function refCount(t) {
     return t.properties?.filter(x => x.attributes?.some(x => x.name === 'References')).length || 0;
 }
@@ -140,7 +165,7 @@ export function tsdWithoutPrompt(tsd) {
 }
 export function parseTsdHeader(tsd) {
     const header = tsd.includes('/*prompt:')
-        ? leftPart(rightPart(tsd, '/*prompt:'), '*/').trim()
+        ? leftPart(rightPart(tsd, '/*prompt:') ?? '', '*/').trim()
         : null;
     if (!header)
         return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "okai",
   "type": "module",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "bin": "./dist/okai.js",
   "main": "./dist/index.js",
   "module": "./dist/index.js",