@cheetah.js/orm 0.1.120 → 0.1.122

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,9 +4,6 @@ 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,59 +50,6 @@ 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;
@@ -127,9 +74,19 @@ let OrmService = class OrmService {
                             nullables.push(propertyName);
                         }
                         if (initializer) {
-                            const defaultValue = this.resolveDefaultValue(initializer);
-                            if (typeof defaultValue !== 'undefined') {
-                                defaults[propertyName] = defaultValue;
+                            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:
+                                    break;
                             }
                         }
                         this.allEntities.set(classDeclaration.getName(), { nullables, defaults });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.120",
+  "version": "0.1.122",
   "description": "A simple ORM for Cheetah.js",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "9c55643b2b3276698e20437ad23ba5f09f3759c4"
+  "gitHead": "d3f748547f20d75d4102b13139a0554a3db953c8"
 }