okai 0.0.36 → 0.0.37

package/dist/api.d.ts

@@ -19,6 +19,7 @@ declare global {
     export class TimeSpan {}
     export class DateOnly {}
     export class TimeOnly {}
+    export class DateTimeOffset {}
     export class Guid {}
     export class List<T> {}
     export class HashSet<T> {}

package/dist/client.js

@@ -1,3 +1,142 @@
+import { lastRightPart, leftPart, toCamelCase, toPascalCase } from "./utils.js";
 export function getFileContent(file) {
     return file.content;
 }
+const converter = {
+    jsTypeMap: {
+        Int64: 'long',
+        Int32: 'number',
+        Int16: 'short',
+        UInt16: 'ushort',
+        UInt64: 'ulong',
+        Boolean: 'boolean',
+        String: 'string',
+        'Byte': 'byte',
+        'Byte[]': 'Uint8Array',
+        'BitArray': 'Uint8Array',
+        'Char': 'string',
+        'Char[]': 'string',
+        Single: 'float',
+        Double: 'double',
+        Decimal: 'decimal',
+        DateTime: 'Date',
+        TimeSpan: 'TimeSpan',
+        DateOnly: 'DateOnly',
+        TimeOnly: 'TimeOnly',
+        Guid: 'Guid',
+        Xml: 'String',
+        Object: 'any',
+        DateTimeOffset: 'DateTimeOffset',
+        'BigInteger': 'BigInt',
+        'Dictionary<string,string>': 'Record<string,string>',
+        'IDictionary<string,string>': 'Record<string,string>',
+    },
+    // https://www.npgsql.org/doc/types/basic.html
+    jsDateTypeMap: {
+        'boolean': 'boolean',
+        'smallint': 'short',
+        'integer': 'number',
+        'bigint': 'long',
+        'real': 'float',
+        'numeric': 'decimal',
+        'money': 'decimal',
+        'text': 'string',
+        'character varying': 'string',
+        'character': 'string',
+        'citext': 'string',
+        'json': 'string',
+        'jsonb': 'string',
+        'xml': 'string',
+        'uuid': 'Guid',
+        'bytea': 'Uint8Array',
+        'timestamp without time zone': 'Date',
+        'timestamp with time zone': 'Date',
+        'date': 'Date',
+        'time without time zone': 'TimeSpan',
+        'time with time zone': 'DateTimeOffset',
+        'interval': 'TimeSpan',
+        'bit(1)': 'boolean',
+        'bit varying': 'Uint8Array',
+        'oid': 'uint',
+        'xid': 'uint',
+        'cid': 'uint',
+        'oidvector': 'uint[]',
+        'name': 'string',
+        'hstore': 'Record<string,string>',
+        'double precision': 'double',
+    },
+    rules: {
+        equals: {},
+        prefix: {
+            date: 'Date',
+            time: 'TimeSpan',
+        },
+        suffix: {
+            'Date': 'Date',
+            'Time': 'TimeSpan',
+            'Utc': 'DateTimeOffset',
+            'At': 'Date',
+            'Start': 'Date',
+            'End': 'Date',
+            'Enabled': 'boolean',
+            'Confirmed': 'boolean',
+        }
+    }
+};
+function toJsType(name, fullType, dataTypeName) {
+    const type = lastRightPart(fullType, '.');
+    if (type === 'Array') {
+        const dataType = leftPart(dataTypeName, '[');
+        const jsType = converter.jsDateTypeMap[dataType];
+        return jsType ? jsType + '[]' : 'any[]';
+    }
+    for (const [k, v] of Object.entries(converter.rules.prefix)) {
+        if (name.startsWith(k)) {
+            return v;
+        }
+    }
+    for (const [k, v] of Object.entries(converter.rules.suffix)) {
+        if (name.endsWith(k)) {
+            return v;
+        }
+    }
+    let jsType = converter.jsTypeMap[type];
+    return jsType ?? type;
+}
+export function convertDefinitionsToAst(definitions) {
+    const r = {
+        config: {},
+        defaultExport: {},
+        references: [],
+        classes: [],
+        interfaces: [],
+        enums: []
+    };
+    for (const def of definitions) {
+        if (!def.name) {
+            console.log('Table definition:', JSON.stringify(def, null, 2));
+            throw new Error('Table definition must have a name');
+        }
+        const cls = {
+            name: toPascalCase(def.name),
+            properties: def.columns.map(x => {
+                const ret = {
+                    name: toCamelCase(x.columnName),
+                    type: toJsType(x.columnName, x.dataType, x.dataTypeName),
+                    optional: x.allowDBNull,
+                };
+                if (x.isKey) {
+                    if (x.isAutoIncrement) {
+                        ret.annotations = [{ name: 'autoIncrement' }];
+                    }
+                    else {
+                        ret.annotations = [{ name: 'primaryKey' }];
+                    }
+                }
+                return ret;
+            }),
+        };
+        r.classes.push(cls);
+    }
+    return r;
+}

package/dist/index.js

@@ -6,7 +6,7 @@ import { leftPart, replaceMyApp, trimStart, toPascalCase, plural } from "./utils
 import { generateCsAstFromTsd, toAst, astForProject } from "./ts-ast.js";
 import { CSharpApiGenerator } from "./cs-apis.js";
 import { CSharpMigrationGenerator } from "./cs-migrations.js";
-import { getFileContent } from "./client.js";
+import { convertDefinitionsToAst, getFileContent } from "./client.js";
 import { toTsd } from "./tsd-gen.js";
 import { UiMjsGroupGenerator, UiMjsIndexGenerator } from "./ui-mjs.js";
 function normalizeSwitches(cmd) { return cmd.replace(/^-+/, '/'); }
@@ -60,7 +60,7 @@ function parseArgs(...args) {
                     break;
             }
         }
-        else if (ret.type === "help" && ["help", "info", "init", "ls", "add", "rm", "update", "accept"].includes(arg)) {
+        else if (ret.type === "help" && ["help", "info", "init", "ls", "add", "rm", "update", "accept", "convert"].includes(arg)) {
             if (arg == "help")
                 ret.type = "help";
             else if (arg == "info")
@@ -97,6 +97,10 @@ function parseArgs(...args) {
                 ret.type = "accept";
                 ret.accept = args[++i];
             }
+            else if (arg == "convert") {
+                ret.type = "convert";
+                ret.convert = args[++i];
+            }
         }
         else if (arg == "chat") {
             ret.type = "chat";
@@ -169,24 +173,25 @@ export async function cli(cmdArgs) {
         }
         const bin = script.padStart(7, ' ');
         console.log(`Usage: 
-${bin} <prompt>             Generate new TypeScript Data Models, C# APIs and Migrations from prompt
-    -m, -models <model,>     Specify up to 5 LLM models to generate .d.ts Data Models
-    -l, -license <LC-xxx>    Specify valid license certificate or key to use premium models
+${bin} <prompt>               Generate new TypeScript Data Models, C# APIs and Migrations from prompt
+    -m, -models <model,>       Specify up to 5 LLM models to generate .d.ts Data Models
+    -l, -license <LC-xxx>      Specify valid license certificate or key to use premium models
 
-${bin} <models>.d.ts        Regenerate C# *.cs files for Data Models defined in the TypeScript .d.ts file
-    -w, -watch               Watch for changes to <models>.d.ts and regenerate *.cs on save
+${bin} <models>.d.ts          Regenerate C# *.cs files for Data Models defined in the TypeScript .d.ts file
+    -w, -watch                 Watch for changes to <models>.d.ts and regenerate *.cs on save
 
-${bin} rm <models>.d.ts     Remove <models>.d.ts and its generated *.cs files
-${bin} ls models            Display list of available premium LLM models
-${bin} init                 Initialize okai.json with project info to override default paths
-${bin} init <model>         Create an empty <model>.d.ts file for the specified model
-${bin} info                 Display current project info
-${bin} chat <prompt>        Submit a new OpenAI chat request with the specified prompt
-    -system <prompt>         Specify a system prompt
+${bin} rm <models>.d.ts       Remove <models>.d.ts and its generated *.cs files
+${bin} ls models              Display list of available premium LLM models
+${bin} init                   Initialize okai.json with project info to override default paths
+${bin} init <model>           Create an empty <model>.d.ts file for the specified model
+${bin} convert <schema.json>  Convert .NET RDBMS TableDefinitions to TypeScript Data Models
+${bin} info                   Display current project info
+${bin} chat <prompt>          Submit a new OpenAI chat request with the specified prompt
+    -system <prompt>           Specify a system prompt
 
-Options:
-    -v, -verbose             Display verbose logging
-        --ignore-ssl-errors  Ignore SSL Errors`);
+Options:  
+    -v, -verbose               Display verbose logging
+        --ignore-ssl-errors    Ignore SSL Errors`);
         process.exit(exitCode);
         return;
     }
@@ -387,6 +392,12 @@ Options:
             fs.writeFileSync(tsdPath, newTsdContent, { encoding: 'utf-8' });
             return newTsdContent;
         }
+        if (info.serviceModelDir) {
+            const relativeServiceModelDir = trimStart(info.serviceModelDir.substring(info.slnDir.length), '~/');
+            const apiTypesPath = path.join(info.slnDir, relativeServiceModelDir, `api.d.ts`);
+            const apiFile = path.join(import.meta.dirname, 'api.d.ts');
+            fs.writeFileSync(apiTypesPath, fs.readFileSync(apiFile, 'utf-8'));
+        }
         if (command.watch) {
             let lastTsdContent = tsdContent;
             console.log(`watching ${tsdPath} ...`);
@@ -410,6 +421,25 @@ Options:
             process.exit(0);
         }
     }
+    if (command.type == "convert") {
+        const dbJson = fs.readFileSync(command.convert, 'utf-8');
+        const tableDefs = JSON.parse(dbJson);
+        const tsdAst = convertDefinitionsToAst(tableDefs);
+        const groupName = path.basename(command.convert).replace('.json', '');
+        const apiFileName = `${groupName}.cs`;
+        let uiFileName = info.uiMjsDir ? `${groupName}.mjs` : null;
+        if (tsdAst.references.length == 0) {
+            tsdAst.references.push({ path: './api.d.ts' });
+        }
+        const tsdContent = createTsdFile(info, {
+            prompt: path.basename(command.convert),
+            apiFileName,
+            tsdAst: tsdAst,
+            uiFileName,
+        });
+        console.log(tsdContent);
+        process.exit(0);
+    }
     if (command.type === "remove") {
         let tsdPath = assertTsdPath(command.tsdFile);
         if (command.verbose)

package/dist/ts-once.js

@@ -1,10 +1,11 @@
-import { pick, toCamelCase, toPascalCase } from "./utils.js";
+import { pick, splitCase, toCamelCase, toPascalCase } from "./utils.js";
 // Tranforms that are only applied once on AI TypeScript AST
 export function createTdAstFromAIAst(tsAst, gropName) {
     mergeInterfacesAndClasses(tsAst);
     rewriteToPascalCase(tsAst);
     replaceReferences(tsAst);
     replaceIds(tsAst);
+    replaceConflictTypes(tsAst);
     tsAst.classes.forEach(cls => {
         // replaceUserRefs(cls)
         replaceUserBaseClass(cls);
@@ -97,6 +98,34 @@ function replaceUserBaseClass(type) {
         }
     }
 }
+function replaceConflictTypes(gen) {
+    const conflictTypeNames = [`Service`, `Task`];
+    const conflictTypes = gen.classes.filter(x => conflictTypeNames.includes(x.name));
+    for (const conflictType of conflictTypes) {
+        const firstFkProp = conflictType.properties?.find(x => x.name.endsWith('Id'));
+        if (firstFkProp) {
+            const splitWords = splitCase(firstFkProp.name).split(' ');
+            const prefix = splitWords.length >= 2 ? splitWords[splitWords.length - 2] : null;
+            if (prefix) {
+                const newType = `${toPascalCase(prefix)}${conflictType.name}`;
+                const conflictTypeName = conflictType.name;
+                conflictType.name = newType;
+                for (const type of gen.classes) {
+                    if (type.properties) {
+                        for (const prop of type.properties) {
+                            if (prop.type === conflictTypeName) {
+                                prop.type = newType;
+                            }
+                            if (prop.type === `${conflictTypeName}[]`) {
+                                prop.type = `${newType}[]`;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
 function rewriteDuplicateTypePropNames(type) {
     const duplicateTypePropMap = {
         note: 'content',

package/dist/utils.js

@@ -196,7 +196,7 @@ export function toPascalCase(s) {
         return words.map(x => x[0].toUpperCase() + x.substring(1).toLowerCase()).join('');
     }
     if (s.includes('_')) {
-        return s.split('_').map(x => x[0].toUpperCase() + x.substring(1)).join('');
+        return s.split('_').filter(x => x[0]).map(x => x[0].toUpperCase() + x.substring(1)).join('');
     }
     return s.charAt(0).toUpperCase() + s.substring(1);
 }

package/package.json

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