@cheetah.js/orm 0.1.118 → 0.1.121

package/dist/driver/bun-driver.base.d.ts

@@ -54,5 +54,6 @@ export declare abstract class BunDriverBase implements Partial<DriverInterface>
     protected parseForeignKeyDefinition(consDef: string): {
         referencedColumnName: string;
         referencedTableName: string;
-    };
+    } | null;
+    private escapeRegex;
 }

package/dist/driver/bun-driver.base.js

@@ -220,26 +220,29 @@ class BunDriverBase {
         const columnName = row[columnNameField];
         return constraints
             .filter((c) => this.isForeignKeyConstraint(c, columnName))
-            .map((c) => this.parseForeignKeyDefinition(c.consDef));
+            .map((c) => this.parseForeignKeyDefinition(c.consDef))
+            .filter(Boolean);
     }
     isForeignKeyConstraint(constraint, columnName) {
         return (constraint.type === 'FOREIGN KEY' &&
             constraint.consDef.includes(columnName));
     }
     parseForeignKeyDefinition(consDef) {
-        const q = this.getIdentifierQuote();
-        const pattern = new RegExp(`REFERENCES\\s+${q}([^${q}]+)${q}\\s*\\(([^)]+)\\)`);
-        const filter = consDef.match(pattern);
-        if (!filter) {
-            throw new Error('Invalid constraint definition');
-        }
+        const quote = this.getIdentifierQuote();
+        const escapedQuote = this.escapeRegex(quote);
+        const pattern = new RegExp(`REFERENCES\\s+(?:${escapedQuote}([^${escapedQuote}]+)${escapedQuote}|([\\w.]+))\\s*\\(([^)]+)\\)`, 'i');
+        const match = consDef.match(pattern);
+        if (!match)
+            return null;
+        const tableName = (match[1] || match[2]).trim();
+        const columnName = match[3].split(',')[0].trim().replace(new RegExp(escapedQuote, 'g'), '');
         return {
-            referencedColumnName: filter[2]
-                .split(',')[0]
-                .trim()
-                .replace(new RegExp(q, 'g'), ''),
-            referencedTableName: filter[1],
+            referencedColumnName: columnName,
+            referencedTableName: tableName
         };
     }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
 }
 exports.BunDriverBase = BunDriverBase;

package/dist/orm.service.d.ts

@@ -4,6 +4,9 @@ export declare class OrmService {
     private orm;
     private storage;
     private allEntities;
+    private resolveLiteralDefault;
+    private resolveEnumDefault;
+    private resolveDefaultValue;
     constructor(orm: Orm, storage: EntityStorage, entityFile?: string);
     private discoverRelationshipTypes;
     private discoverEnumTypes;

package/dist/orm.service.js

@@ -50,6 +50,59 @@ const ts_morph_1 = require("ts-morph");
 const orm_1 = require("./orm");
 const globby = __importStar(require("globby"));
 let OrmService = class OrmService {
+    resolveLiteralDefault(initializer) {
+        const kind = initializer.getKind();
+        if (kind === ts_morph_1.SyntaxKind.StringLiteral)
+            return initializer.getText();
+        if (kind === ts_morph_1.SyntaxKind.NumericLiteral)
+            return parseFloat(initializer.getText());
+        if (kind === ts_morph_1.SyntaxKind.TrueKeyword)
+            return true;
+        if (kind === ts_morph_1.SyntaxKind.FalseKeyword)
+            return false;
+        if (kind !== ts_morph_1.SyntaxKind.ArrayLiteralExpression)
+            return;
+        const elements = initializer.getElements();
+        return elements
+            .map((element) => {
+            const kind = element.getKind();
+            if (kind === ts_morph_1.SyntaxKind.StringLiteral ||
+                kind === ts_morph_1.SyntaxKind.NumericLiteral ||
+                kind === ts_morph_1.SyntaxKind.TrueKeyword ||
+                kind === ts_morph_1.SyntaxKind.FalseKeyword ||
+                kind === ts_morph_1.SyntaxKind.ArrayLiteralExpression) {
+                return this.resolveLiteralDefault(element);
+            }
+            else if (kind === ts_morph_1.SyntaxKind.PropertyAccessExpression) {
+                return this.resolveEnumDefault(element);
+            }
+            return undefined;
+        })
+            .filter((value) => typeof value !== 'undefined');
+    }
+    resolveEnumDefault(initializer) {
+        if (initializer.getKind() !== ts_morph_1.SyntaxKind.PropertyAccessExpression)
+            return;
+        const [enumName, memberName] = initializer.getText().split('.');
+        if (!enumName || !memberName)
+            return;
+        const enumDeclaration = initializer.getSourceFile().getEnum(enumName) ||
+            initializer.getSourceFile().getProject().getSourceFiles()
+                .map(file => file.getEnum(enumName))
+                .find(item => item);
+        if (!enumDeclaration)
+            return;
+        const member = enumDeclaration.getMember(memberName);
+        if (!member)
+            return;
+        const value = member.getValue();
+        return typeof value === 'undefined' ? member.getName() : value;
+    }
+    resolveDefaultValue(initializer) {
+        const value = this.resolveLiteralDefault(initializer) ??
+            this.resolveEnumDefault(initializer);
+        return value;
+    }
     constructor(orm, storage, entityFile) {
         this.orm = orm;
         this.storage = storage;
@@ -74,20 +127,9 @@ let OrmService = class OrmService {
                             nullables.push(propertyName);
                         }
                         if (initializer) {
-                            const initializerKind = initializer.getKind();
-                            switch (initializerKind) {
-                                case ts_morph_1.SyntaxKind.StringLiteral:
-                                    defaults[propertyName] = initializer.getText();
-                                    break;
-                                case ts_morph_1.SyntaxKind.NumericLiteral:
-                                    defaults[propertyName] = parseFloat(initializer.getText());
-                                    break;
-                                case ts_morph_1.SyntaxKind.NewExpression:
-                                case ts_morph_1.SyntaxKind.CallExpression:
-                                    break;
-                                default:
-                                    defaults[propertyName] = () => initializer.getText();
-                                    break;
+                            const defaultValue = this.resolveDefaultValue(initializer);
+                            if (typeof defaultValue !== 'undefined') {
+                                defaults[propertyName] = defaultValue;
                             }
                         }
                         this.allEntities.set(classDeclaration.getName(), { nullables, defaults });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.118",
+  "version": "0.1.121",
   "description": "A simple ORM for Cheetah.js",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "d5b23c4d1d3d720a93e3e157e658b8e57c828251"
+  "gitHead": "04085d38962dd22e3967a52f00a7a9fa67746c6e"
 }