@uql/core 3.4.0 → 3.4.2

package/dist/browser/uql-browser.min.js

@@ -1,2150 +1,1014 @@
-import { isSqlQuerier } from '../type/index.js';
-export { isSqlQuerier } from '../type/index.js';
-import { AbstractDialect } from '../dialect/index.js';
-import { getMeta, getEntities } from '../entity/index.js';
-import { escapeSqlId, getKeys } from '../util/index.js';
-import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
-import { join, basename, extname, dirname } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { _ as _apply_decs_2203_r } from './cc-BEf4wTUm.js';
+import { randomUUID } from 'node:crypto';
+import { Id, Field, ManyToOne, Entity, OneToOne, OneToMany, ManyToMany } from '../entity/index.js';
+import '../type/index.js';
+import { raw, lowerFirst, upperFirst, getKeys } from '../util/index.js';
+import 'reflect-metadata';
+import { describe, afterAll, afterEach, beforeEach, beforeAll, it } from 'bun:test';
 
+var _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, /**
+   * auto-generated primary-key (when the `onInsert` property is omitted).
+   */ _init_id, /**
+   * foreign-keys are really simple to specify with the `reference` property.
+   */ _init_companyId, /**
+   * The `Relation` wrapper type can be used in ESM projects for the relations to
+   * avoid circular dependency issues.
+   */ _init_company, _init_creatorId, _init_creator, /**
+   * 'onInsert' property can be used to specify a custom mechanism for
+   * obtaining the value of a field when inserting:
+   */ _init_createdAt, /**
+   * 'onUpdate' property can be used to specify a custom mechanism for
+   * obtaining the value of a field when updating:
+   */ _init_updatedAt, _dec7, _initClass, _BaseEntity, _dec8, _dec9, _dec10, _init_name, _init_description, _init_kind, _dec11, _initClass1, _BaseEntity1, _dec12, _dec13, /**
+   * an entity can specify its own ID Field and still inherit the others
+   * columns/relations from its parent entity.
+   */ _init_pk, _init_picture, _dec14, _initClass2, _BaseEntity2, _dec15, _dec16, _dec17, _dec18, _dec19, _init_name1, _init_email, _init_password, /**
+   * `mappedBy` property can be a callback or a string (callback is useful for auto-refactoring).
+   */ _init_profile, _init_users, _dec20, _initClass3, _dec21, _dec22, _init_id1, _init_name2, _dec23, _initClass4, _BaseEntity3, _dec24, _dec25, _dec26, _dec27, _init_name3, _init_description1, _init_parentLedgerId, _init_parentLedger, _dec28, _initClass5, _BaseEntity4, _dec29, _dec30, _dec31, /**
+   * an entity can override the ID Field and still inherit the others
+   * columns/relations from its parent entity.
+   * 'onInsert' property can be used to specify a custom mechanism for
+   * auto-generating the primary-key's value when inserting.
+   */ _init_pk1, _init_name4, _init_description2, _dec32, _initClass6, _BaseEntity5, _dec33, _dec34, _dec35, _dec36, _dec37, _init_name5, _init_percentage, _init_categoryId, _init_category, _init_description3, _dec38, _initClass7, _BaseEntity6, _dec39, _dec40, _dec41, _init_name6, _init_measureUnits, /**
+   * `onDelete` callback allows to specify which field will be used when deleting/querying this entity.
+   */ _init_deletedAt, _dec42, _initClass8, _BaseEntity7, _dec43, _dec44, _dec45, _dec46, _init_name7, _init_categoryId1, _init_category1, _init_deletedAt1, _dec47, _initClass9, _BaseEntity8, _dec48, _dec49, _dec50, _init_name8, _init_address, _init_description4, _dec51, _initClass10, _BaseEntity9, _dec52, _dec53, _dec54, _dec55, _dec56, _dec57, _dec58, _dec59, _dec60, _dec61, _dec62, _dec63, _dec64, _dec65, _dec66, _init_name9, _init_description5, _init_code, _init_buyLedgerAccountId, _init_buyLedgerAccount, _init_saleLedgerAccountId, _init_saleLedgerAccount, _init_taxId, _init_tax, _init_measureUnitId, _init_measureUnit, _init_salePrice, _init_inventoryable, _init_tags, _init_tagsCount, _dec67, _initClass11, _BaseEntity10, _dec68, _dec69, _dec70, _init_name10, _init_items, _init_itemsCount, _dec71, _initClass12, _dec72, _dec73, _dec74, _init_id2, _init_itemId, _init_tagId, _dec75, _initClass13, _BaseEntity11, _dec76, _dec77, _dec78, _init_itemAdjustments, _init_date, _init_description6, _dec79, _initClass14, _BaseEntity12, _dec80, _dec81, _dec82, _dec83, _dec84, _dec85, _dec86, _dec87, _init_itemId1, _init_item, _init_number, _init_buyPrice, _init_storehouseId, _init_storehouse, _init_inventoryAdjustmentId, _init_inventoryAdjustment;
+_dec = Id(), _dec1 = Field({
+    reference: ()=>_Company
+}), _dec2 = ManyToOne({
+    entity: ()=>_Company
+}), _dec3 = Field({
+    reference: ()=>_User
+}), _dec4 = ManyToOne({
+    entity: ()=>_User
+}), _dec5 = Field({
+    onInsert: Date.now
+}), _dec6 = Field({
+    onUpdate: Date.now
+});
 /**
- * Abstract base class for SQL schema generation
- */ class AbstractSchemaGenerator extends AbstractDialect {
-    constructor(namingStrategy, escapeIdChar = '`'){
-        super(namingStrategy), this.escapeIdChar = escapeIdChar;
-    }
-    /**
-   * Escape an identifier (table name, column name, etc.)
-   */ escapeId(identifier) {
-        return escapeSqlId(identifier, this.escapeIdChar);
-    }
-    generateCreateTable(entity, options = {}) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        const columns = this.generateColumnDefinitions(meta);
-        const constraints = this.generateTableConstraints(meta);
-        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
-        let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\n`;
-        sql += columns.map((col)=>`  ${col}`).join(',\n');
-        if (constraints.length > 0) {
-            sql += ',\n';
-            sql += constraints.map((c)=>`  ${c}`).join(',\n');
-        }
-        sql += '\n)';
-        sql += this.getTableOptions(meta);
-        sql += ';';
-        return sql;
-    }
-    generateDropTable(entity) {
-        const meta = getMeta(entity);
-        const tableName = this.resolveTableName(entity, meta);
-        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
-    }
-    generateAlterTable(diff) {
-        const statements = [];
-        const tableName = this.escapeId(diff.tableName);
-        // Add new columns
-        if (diff.columnsToAdd?.length) {
-            for (const column of diff.columnsToAdd){
-                const colDef = this.generateColumnDefinitionFromSchema(column);
-                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);
-            }
-        }
-        // Alter existing columns
-        if (diff.columnsToAlter?.length) {
-            for (const { to } of diff.columnsToAlter){
-                const colDef = this.generateColumnDefinitionFromSchema(to);
-                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
-                statements.push(...colStatements);
-            }
-        }
-        // Drop columns
-        if (diff.columnsToDrop?.length) {
-            for (const columnName of diff.columnsToDrop){
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
-            }
-        }
-        // Add indexes
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd){
-                statements.push(this.generateCreateIndex(diff.tableName, index));
-            }
-        }
-        // Drop indexes
-        if (diff.indexesToDrop?.length) {
-            for (const indexName of diff.indexesToDrop){
-                statements.push(this.generateDropIndex(diff.tableName, indexName));
-            }
-        }
-        return statements;
-    }
-    generateAlterTableDown(diff) {
-        const statements = [];
-        const tableName = this.escapeId(diff.tableName);
-        // Rollback additions by dropping columns
-        if (diff.columnsToAdd?.length) {
-            for (const column of diff.columnsToAdd){
-                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
-            }
-        }
-        return statements;
-    }
-    generateCreateIndex(tableName, index) {
-        const unique = index.unique ? 'UNIQUE ' : '';
-        const columns = index.columns.map((c)=>this.escapeId(c)).join(', ');
-        return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
-    }
-    generateDropIndex(tableName, indexName) {
-        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
-    }
-    /**
-   * Generate column definitions from entity metadata
-   */ generateColumnDefinitions(meta) {
-        const columns = [];
-        const fieldKeys = getKeys(meta.fields);
-        for (const key of fieldKeys){
-            const field = meta.fields[key];
-            if (field?.virtual) continue; // Skip virtual fields
-            const colDef = this.generateColumnDefinition(key, field, meta);
-            columns.push(colDef);
-        }
-        return columns;
-    }
-    /**
-   * Generate a single column definition
-   */ generateColumnDefinition(fieldKey, field, meta) {
-        const columnName = this.escapeId(this.resolveColumnName(fieldKey, field));
-        const isId = field.isId === true;
-        const isPrimaryKey = isId && meta.id === fieldKey;
-        // Determine SQL type
-        let sqlType;
-        if (isPrimaryKey && field.autoIncrement !== false && !field.onInsert) {
-            // Auto-increment primary key
-            sqlType = this.serialPrimaryKeyType;
-        } else {
-            sqlType = this.getSqlType(field, field.type);
-        }
-        let definition = `${columnName} ${sqlType}`;
-        // PRIMARY KEY constraint (for non-serial types)
-        if (isPrimaryKey && !sqlType.includes('PRIMARY KEY')) {
-            definition += ' PRIMARY KEY';
-        }
-        // NULL/NOT NULL
-        if (!isPrimaryKey) {
-            const nullable = field.nullable ?? true;
-            if (!nullable) {
-                definition += ' NOT NULL';
-            }
-        }
-        // UNIQUE constraint
-        if (field.unique && !isPrimaryKey) {
-            definition += ' UNIQUE';
-        }
-        // DEFAULT value
-        if (field.defaultValue !== undefined) {
-            definition += ` DEFAULT ${this.formatDefaultValue(field.defaultValue)}`;
-        }
-        // COMMENT (if supported)
-        if (field.comment) {
-            definition += this.generateColumnComment(this.resolveTableName(meta.entity, meta), this.resolveColumnName(fieldKey, field), field.comment);
-        }
-        return definition;
-    }
-    /**
-   * Generate column definition from a ColumnSchema object
-   */ generateColumnDefinitionFromSchema(column) {
-        const columnName = this.escapeId(column.name);
-        let type = column.type;
-        if (column.length && !type.includes('(')) {
-            type = `${type}(${column.length})`;
-        } else if (column.precision !== undefined && !type.includes('(')) {
-            if (column.scale !== undefined) {
-                type = `${type}(${column.precision}, ${column.scale})`;
-            } else {
-                type = `${type}(${column.precision})`;
-            }
-        }
-        let definition = `${columnName} ${type}`;
-        if (column.isPrimaryKey) {
-            definition += ' PRIMARY KEY';
-        }
-        if (!column.nullable && !column.isPrimaryKey) {
-            definition += ' NOT NULL';
-        }
-        if (column.isUnique && !column.isPrimaryKey) {
-            definition += ' UNIQUE';
-        }
-        if (column.defaultValue !== undefined) {
-            definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
-        }
-        return definition;
-    }
-    /**
-   * Generate table constraints (indexes, foreign keys, etc.)
-   */ generateTableConstraints(meta) {
-        const constraints = [];
-        const fieldKeys = getKeys(meta.fields);
-        const tableName = this.resolveTableName(meta.entity, meta);
-        // Generate indexes from field options
-        for (const key of fieldKeys){
-            const field = meta.fields[key];
-            if (field?.index) {
-                const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
-                constraints.push(`INDEX ${this.escapeId(indexName)} (${this.escapeId(columnName)})`);
-            }
-        }
-        // Generate foreign key constraints from references
-        for (const key of fieldKeys){
-            const field = meta.fields[key];
-            if (field?.reference) {
-                const refEntity = field.reference();
-                const refMeta = getMeta(refEntity);
-                const refIdField = refMeta.fields[refMeta.id];
-                const columnName = this.resolveColumnName(key, field);
-                const refTableName = this.resolveTableName(refEntity, refMeta);
-                const refColumnName = this.resolveColumnName(refMeta.id, refIdField);
-                const fkName = `fk_${tableName}_${columnName}`;
-                constraints.push(`CONSTRAINT ${this.escapeId(fkName)} FOREIGN KEY (${this.escapeId(columnName)}) ` + `REFERENCES ${this.escapeId(refTableName)} (${this.escapeId(refColumnName)})`);
-            }
-        }
-        return constraints;
-    }
-    getSqlType(field, fieldType) {
-        // Use explicit column type if specified
-        if (field.columnType) {
-            return this.mapColumnType(field.columnType, field);
-        }
-        // Handle special types
-        if (field.type === 'json' || field.type === 'jsonb') {
-            return this.mapColumnType(field.type, field);
-        }
-        if (field.type === 'vector') {
-            return this.mapColumnType('vector', field);
-        }
-        // Infer from TypeScript type
-        const type = fieldType ?? field.type;
-        if (type === Number || type === 'number') {
-            return field.precision ? this.mapColumnType('decimal', field) : 'BIGINT';
-        }
-        if (type === String || type === 'string') {
-            const length = field.length ?? 255;
-            return `VARCHAR(${length})`;
-        }
-        if (type === Boolean || type === 'boolean') {
-            return this.getBooleanType();
-        }
-        if (type === Date || type === 'date') {
-            return 'TIMESTAMP';
-        }
-        if (type === BigInt || type === 'bigint') {
-            return 'BIGINT';
-        }
-        // Default to VARCHAR
-        return `VARCHAR(${field.length ?? 255})`;
-    }
-    /**
-   * Get table options (e.g., ENGINE for MySQL)
-   */ getTableOptions(meta) {
-        return '';
-    }
-    /**
-   * Format a default value for SQL
-   */ formatDefaultValue(value) {
-        if (value === null) {
-            return 'NULL';
-        }
-        if (typeof value === 'string') {
-            return `'${value.replace(/'/g, "''")}'`;
-        }
-        if (typeof value === 'boolean') {
-            return value ? 'TRUE' : 'FALSE';
-        }
-        if (typeof value === 'number' || typeof value === 'bigint') {
-            return String(value);
-        }
-        if (value instanceof Date) {
-            return `'${value.toISOString()}'`;
-        }
-        return String(value);
-    }
-    /**
-   * Compare two schemas and return the differences
-   */ diffSchema(entity, currentSchema) {
-        const meta = getMeta(entity);
-        if (!currentSchema) {
-            // Table doesn't exist, need to create
-            return {
-                tableName: this.resolveTableName(entity, meta),
-                type: 'create'
-            };
-        }
-        const columnsToAdd = [];
-        const columnsToAlter = [];
-        const columnsToDrop = [];
-        const currentColumns = new Map(currentSchema.columns.map((c)=>[
-                c.name,
-                c
-            ]));
-        const fieldKeys = getKeys(meta.fields);
-        // Check for new or altered columns
-        for (const key of fieldKeys){
-            const field = meta.fields[key];
-            if (field?.virtual) continue;
-            const columnName = this.resolveColumnName(key, field);
-            const currentColumn = currentColumns.get(columnName);
-            if (!currentColumn) {
-                // Column needs to be added
-                columnsToAdd.push(this.fieldToColumnSchema(key, field, meta));
-            } else {
-                // Check if column needs alteration
-                const desiredColumn = this.fieldToColumnSchema(key, field, meta);
-                if (this.columnsNeedAlteration(currentColumn, desiredColumn)) {
-                    columnsToAlter.push({
-                        from: currentColumn,
-                        to: desiredColumn
-                    });
-                }
-            }
-            currentColumns.delete(columnName);
-        }
-        // Remaining columns in currentColumns should be dropped
-        for (const [name] of currentColumns){
-            columnsToDrop.push(name);
-        }
-        if (columnsToAdd.length === 0 && columnsToAlter.length === 0 && columnsToDrop.length === 0) {
-            return undefined; // No changes needed
-        }
-        return {
-            tableName: this.resolveTableName(entity, meta),
-            type: 'alter',
-            columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
-            columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
-            columnsToDrop: columnsToDrop.length > 0 ? columnsToDrop : undefined
-        };
-    }
-    /**
-   * Convert field options to ColumnSchema
-   */ fieldToColumnSchema(fieldKey, field, meta) {
-        const isId = field.isId === true;
-        const isPrimaryKey = isId && meta.id === fieldKey;
-        return {
-            name: this.resolveColumnName(fieldKey, field),
-            type: this.getSqlType(field, field.type),
-            nullable: field.nullable ?? !isPrimaryKey,
-            defaultValue: field.defaultValue,
-            isPrimaryKey,
-            isAutoIncrement: isPrimaryKey && field.autoIncrement !== false && !field.onInsert,
-            isUnique: field.unique ?? false,
-            length: field.length,
-            precision: field.precision,
-            scale: field.scale,
-            comment: field.comment
-        };
-    }
-    /**
-   * Check if two columns differ enough to require alteration
-   */ columnsNeedAlteration(current, desired) {
-        // Compare relevant properties
-        return current.type.toLowerCase() !== desired.type.toLowerCase() || current.nullable !== desired.nullable || current.isUnique !== desired.isUnique || JSON.stringify(current.defaultValue) !== JSON.stringify(desired.defaultValue);
+ * an `abstract` class can (optionally) be used as the base "template" for the entities
+ * (so common fields' declaration is easily reused).
+ */ class BaseEntity {
+    static{
+        ({ e: [_init_id, _init_companyId, _init_company, _init_creatorId, _init_creator, _init_createdAt, _init_updatedAt] } = _apply_decs_2203_r(this, [
+            [
+                _dec,
+                0,
+                "id"
+            ],
+            [
+                _dec1,
+                0,
+                "companyId"
+            ],
+            [
+                _dec2,
+                0,
+                "company"
+            ],
+            [
+                _dec3,
+                0,
+                "creatorId"
+            ],
+            [
+                _dec4,
+                0,
+                "creator"
+            ],
+            [
+                _dec5,
+                0,
+                "createdAt"
+            ],
+            [
+                _dec6,
+                0,
+                "updatedAt"
+            ]
+        ], []));
+    }
+    constructor(){
+        this.id = _init_id(this);
+        this.companyId = _init_companyId(this);
+        this.company = _init_company(this);
+        this.creatorId = _init_creatorId(this);
+        this.creator = _init_creator(this);
+        this.createdAt = _init_createdAt(this);
+        this.updatedAt = _init_updatedAt(this);
     }
 }
-
-/**
- * MySQL/MariaDB-specific schema generator
- */ class MysqlSchemaGenerator extends AbstractSchemaGenerator {
-    mapColumnType(columnType, field) {
-        switch(columnType){
-            case 'int':
-                return 'INT';
-            case 'smallint':
-                return 'SMALLINT';
-            case 'bigint':
-                return 'BIGINT';
-            case 'float':
-                return 'FLOAT';
-            case 'double':
-            case 'real':
-                return 'DOUBLE';
-            case 'decimal':
-            case 'numeric':
-                if (field.precision !== undefined) {
-                    if (field.scale !== undefined) {
-                        return `DECIMAL(${field.precision}, ${field.scale})`;
-                    }
-                    return `DECIMAL(${field.precision})`;
-                }
-                return 'DECIMAL(10, 2)';
-            case 'boolean':
-                return 'TINYINT(1)';
-            case 'char':
-                return `CHAR(${field.length ?? 1})`;
-            case 'varchar':
-                return `VARCHAR(${field.length ?? 255})`;
-            case 'text':
-                return 'TEXT';
-            case 'uuid':
-                return 'CHAR(36)';
-            case 'date':
-                return 'DATE';
-            case 'time':
-                return 'TIME';
-            case 'timestamp':
-            case 'timestamptz':
-                return 'TIMESTAMP';
-            case 'json':
-            case 'jsonb':
-                return 'JSON';
-            case 'blob':
-            case 'bytea':
-                return 'BLOB';
-            case 'vector':
-                // MySQL doesn't have native vector support, use JSON
-                return 'JSON';
-            case 'serial':
-                return 'INT AUTO_INCREMENT';
-            case 'bigserial':
-                return 'BIGINT AUTO_INCREMENT';
-            default:
-                return 'TEXT';
-        }
-    }
-    getBooleanType() {
-        return 'TINYINT(1)';
-    }
-    generateAlterColumnStatements(tableName, column, newDefinition) {
-        return [
-            `ALTER TABLE ${this.escapeId(tableName)} MODIFY COLUMN ${newDefinition};`
-        ];
-    }
-    generateColumnComment(tableName, columnName, comment) {
-        const escapedComment = comment.replace(/'/g, "''");
-        return ` COMMENT '${escapedComment}'`;
-    }
-    getTableOptions() {
-        return ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
-    }
-    generateDropIndex(tableName, indexName) {
-        // MySQL requires table name in DROP INDEX
-        return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
+let _Company;
+_dec7 = Entity(), _dec8 = Field(), _dec9 = Field(), _dec10 = Field({
+    type: 'jsonb'
+});
+class Company extends (_BaseEntity = BaseEntity) {
+    static{
+        ({ e: [_init_name, _init_description, _init_kind], c: [_Company, _initClass] } = _apply_decs_2203_r(this, [
+            [
+                _dec8,
+                0,
+                "name"
+            ],
+            [
+                _dec9,
+                0,
+                "description"
+            ],
+            [
+                _dec10,
+                0,
+                "kind"
+            ]
+        ], [
+            _dec7
+        ], _BaseEntity));
+    }
+    static{
+        _initClass();
     }
     constructor(...args){
-        super(...args), this.serialPrimaryKeyType = 'INT AUTO_INCREMENT PRIMARY KEY';
+        super(...args), this.name = _init_name(this), this.description = _init_description(this), this.kind = _init_kind(this);
     }
 }
-
-/**
- * PostgreSQL-specific schema generator
- */ class PostgresSchemaGenerator extends AbstractSchemaGenerator {
-    constructor(namingStrategy){
-        super(namingStrategy, '"'), this.serialPrimaryKeyType = 'SERIAL PRIMARY KEY';
+let _Profile;
+_dec11 = Entity({
+    name: 'user_profile'
+}), _dec12 = Id(), _dec13 = Field({
+    name: 'image'
+});
+class Profile extends (_BaseEntity1 = BaseEntity) {
+    static{
+        ({ e: [_init_pk, _init_picture], c: [_Profile, _initClass1] } = _apply_decs_2203_r(this, [
+            [
+                _dec12,
+                0,
+                "pk"
+            ],
+            [
+                _dec13,
+                0,
+                "picture"
+            ]
+        ], [
+            _dec11
+        ], _BaseEntity1));
+    }
+    static{
+        _initClass1();
     }
-    mapColumnType(columnType, field) {
-        switch(columnType){
-            case 'int':
-                return 'INTEGER';
-            case 'smallint':
-                return 'SMALLINT';
-            case 'bigint':
-                return 'BIGINT';
-            case 'float':
-            case 'double':
-            case 'real':
-                return 'DOUBLE PRECISION';
-            case 'decimal':
-            case 'numeric':
-                if (field.precision !== undefined) {
-                    if (field.scale !== undefined) {
-                        return `NUMERIC(${field.precision}, ${field.scale})`;
-                    }
-                    return `NUMERIC(${field.precision})`;
-                }
-                return 'NUMERIC';
-            case 'boolean':
-                return 'BOOLEAN';
-            case 'char':
-                return `CHAR(${field.length ?? 1})`;
-            case 'varchar':
-                return `VARCHAR(${field.length ?? 255})`;
-            case 'text':
-                return 'TEXT';
-            case 'uuid':
-                return 'UUID';
-            case 'date':
-                return 'DATE';
-            case 'time':
-                return 'TIME';
-            case 'timestamp':
-                return 'TIMESTAMP';
-            case 'timestamptz':
-                return 'TIMESTAMPTZ';
-            case 'json':
-                return 'JSON';
-            case 'jsonb':
-                return 'JSONB';
-            case 'blob':
-            case 'bytea':
-                return 'BYTEA';
-            case 'vector':
-                if (field.length) {
-                    return `VECTOR(${field.length})`;
-                }
-                return 'VECTOR';
-            case 'serial':
-                return 'SERIAL';
-            case 'bigserial':
-                return 'BIGSERIAL';
-            default:
-                return 'TEXT';
-        }
-    }
-    getBooleanType() {
-        return 'BOOLEAN';
-    }
-    generateAlterColumnStatements(tableName, column, newDefinition) {
-        const statements = [];
-        const escapedTableName = this.escapeId(tableName);
-        const escapedColumnName = this.escapeId(column.name);
-        // PostgreSQL uses separate ALTER COLUMN clauses for different changes
-        // 1. Change type
-        statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} TYPE ${column.type};`);
-        // 2. Change nullability
-        if (column.nullable) {
-            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP NOT NULL;`);
-        } else {
-            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET NOT NULL;`);
-        }
-        // 3. Change default value
-        if (column.defaultValue !== undefined) {
-            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`);
-        } else {
-            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP DEFAULT;`);
-        }
-        return statements;
-    }
-    generateColumnComment(tableName, columnName, comment) {
-        // PostgreSQL handles comments separately via COMMENT ON COLUMN
-        return '';
-    }
-    /**
-   * Generate COMMENT ON COLUMN statement for PostgreSQL
-   */ generateColumnCommentStatement(tableName, columnName, comment) {
-        const escapedComment = comment.replace(/'/g, "''");
-        return `COMMENT ON COLUMN ${this.escapeId(tableName)}.${this.escapeId(columnName)} IS '${escapedComment}';`;
-    }
-    generateDropIndex(tableName, indexName) {
-        // PostgreSQL doesn't require table name in DROP INDEX
-        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    constructor(...args){
+        super(...args), this.pk = _init_pk(this), this.picture = _init_picture(this);
     }
 }
-
-/**
- * SQLite-specific schema generator
- */ class SqliteSchemaGenerator extends AbstractSchemaGenerator {
-    mapColumnType(columnType, field) {
-        // SQLite has dynamic typing, but we use type affinity
-        switch(columnType){
-            case 'int':
-            case 'smallint':
-            case 'bigint':
-            case 'serial':
-            case 'bigserial':
-                return 'INTEGER';
-            case 'float':
-            case 'double':
-            case 'real':
-            case 'decimal':
-            case 'numeric':
-                return 'REAL';
-            case 'boolean':
-                return 'INTEGER'; // SQLite uses 0/1 for booleans
-            case 'char':
-            case 'varchar':
-            case 'text':
-            case 'uuid':
-                return 'TEXT';
-            case 'date':
-            case 'time':
-            case 'timestamp':
-            case 'timestamptz':
-                return 'TEXT'; // SQLite stores dates as TEXT or INTEGER
-            case 'json':
-            case 'jsonb':
-                return 'TEXT'; // SQLite stores JSON as TEXT
-            case 'blob':
-            case 'bytea':
-                return 'BLOB';
-            case 'vector':
-                return 'TEXT'; // Store as JSON array
-            default:
-                return 'TEXT';
-        }
-    }
-    getBooleanType() {
-        return 'INTEGER';
-    }
-    generateAlterColumnStatements(tableName, column, newDefinition) {
-        // SQLite has very limited ALTER TABLE support
-        // Column type changes require recreating the table
-        throw new Error(`SQLite does not support altering column '${column.name}' in table '${tableName}'. ` + 'You need to recreate the table to change column types.');
-    }
-    generateColumnComment(tableName, columnName, comment) {
-        return '';
-    }
-    generateDropIndex(tableName, indexName) {
-        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
-    }
-    formatDefaultValue(value) {
-        if (typeof value === 'boolean') {
-            return value ? '1' : '0';
-        }
-        return super.formatDefaultValue(value);
+let _User;
+_dec14 = Entity(), _dec15 = Field(), _dec16 = Field({
+    updatable: false
+}), _dec17 = Field({
+    eager: false
+}), _dec18 = OneToOne({
+    entity: ()=>_Profile,
+    mappedBy: (profile)=>profile.creator,
+    cascade: true
+}), _dec19 = OneToMany({
+    entity: ()=>_User,
+    mappedBy: 'creator'
+});
+class User extends (_BaseEntity2 = BaseEntity) {
+    static{
+        ({ e: [_init_name1, _init_email, _init_password, _init_profile, _init_users], c: [_User, _initClass2] } = _apply_decs_2203_r(this, [
+            [
+                _dec15,
+                0,
+                "name"
+            ],
+            [
+                _dec16,
+                0,
+                "email"
+            ],
+            [
+                _dec17,
+                0,
+                "password"
+            ],
+            [
+                _dec18,
+                0,
+                "profile"
+            ],
+            [
+                _dec19,
+                0,
+                "users"
+            ]
+        ], [
+            _dec14
+        ], _BaseEntity2));
+    }
+    static{
+        _initClass2();
     }
     constructor(...args){
-        super(...args), this.serialPrimaryKeyType = 'INTEGER PRIMARY KEY AUTOINCREMENT';
+        super(...args), this.name = _init_name1(this), this.email = _init_email(this), this.password = _init_password(this), this.profile = _init_profile(this), this.users = _init_users(this);
     }
 }
-
-/**
- * MySQL/MariaDB schema introspector.
- * Works with both MySQL and MariaDB as they share the same information_schema structure.
- */ class MysqlSchemaIntrospector {
-    constructor(pool){
-        this.pool = pool;
-    }
-    async getTableSchema(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            const exists = await this.tableExistsInternal(querier, tableName);
-            if (!exists) {
-                return undefined;
-            }
-            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
-                this.getColumns(querier, tableName),
-                this.getIndexes(querier, tableName),
-                this.getForeignKeys(querier, tableName),
-                this.getPrimaryKey(querier, tableName)
-            ]);
-            return {
-                name: tableName,
-                columns,
-                primaryKey,
-                indexes,
-                foreignKeys
-            };
-        } finally{
-            await querier.release();
-        }
-    }
-    async getTableNames() {
-        const querier = await this.getQuerier();
-        try {
-            const sql = `
-        SELECT TABLE_NAME as table_name
-        FROM information_schema.TABLES
-        WHERE TABLE_SCHEMA = DATABASE()
-          AND TABLE_TYPE = 'BASE TABLE'
-        ORDER BY TABLE_NAME
-      `;
-            const results = await querier.all(sql);
-            return results.map((r)=>r.table_name);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExists(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            return this.tableExistsInternal(querier, tableName);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExistsInternal(querier, tableName) {
-        const sql = `
-      SELECT COUNT(*) as count
-      FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return (results[0]?.count ?? 0) > 0;
-    }
-    async getQuerier() {
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');
-        }
-        return querier;
-    }
-    async getColumns(querier, tableName) {
-        const sql = `
-      SELECT
-        COLUMN_NAME as column_name,
-        DATA_TYPE as data_type,
-        COLUMN_TYPE as column_type,
-        IS_NULLABLE as is_nullable,
-        COLUMN_DEFAULT as column_default,
-        CHARACTER_MAXIMUM_LENGTH as character_maximum_length,
-        NUMERIC_PRECISION as numeric_precision,
-        NUMERIC_SCALE as numeric_scale,
-        COLUMN_KEY as column_key,
-        EXTRA as extra,
-        COLUMN_COMMENT as column_comment
-      FROM information_schema.COLUMNS
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-      ORDER BY ORDINAL_POSITION
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.column_name,
-                type: row.data_type.toUpperCase(),
-                nullable: row.is_nullable === 'YES',
-                defaultValue: this.parseDefaultValue(row.column_default),
-                isPrimaryKey: row.column_key === 'PRI',
-                isAutoIncrement: row.extra.toLowerCase().includes('auto_increment'),
-                isUnique: row.column_key === 'UNI',
-                length: row.character_maximum_length ?? undefined,
-                precision: row.numeric_precision ?? undefined,
-                scale: row.numeric_scale ?? undefined,
-                comment: row.column_comment || undefined
-            }));
-    }
-    async getIndexes(querier, tableName) {
-        const sql = `
-      SELECT
-        INDEX_NAME as index_name,
-        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
-        NOT NON_UNIQUE as is_unique
-      FROM information_schema.STATISTICS
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-        AND INDEX_NAME != 'PRIMARY'
-      GROUP BY INDEX_NAME, NON_UNIQUE
-      ORDER BY INDEX_NAME
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.index_name,
-                columns: row.columns.split(','),
-                unique: Boolean(row.is_unique)
-            }));
-    }
-    async getForeignKeys(querier, tableName) {
-        const sql = `
-      SELECT
-        kcu.CONSTRAINT_NAME as constraint_name,
-        GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
-        kcu.REFERENCED_TABLE_NAME as referenced_table,
-        GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns,
-        rc.DELETE_RULE as delete_rule,
-        rc.UPDATE_RULE as update_rule
-      FROM information_schema.KEY_COLUMN_USAGE kcu
-      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
-        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-        AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
-      WHERE kcu.TABLE_SCHEMA = DATABASE()
-        AND kcu.TABLE_NAME = ?
-        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
-      GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_NAME, rc.DELETE_RULE, rc.UPDATE_RULE
-      ORDER BY kcu.CONSTRAINT_NAME
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.constraint_name,
-                columns: row.columns.split(','),
-                referencedTable: row.referenced_table,
-                referencedColumns: row.referenced_columns.split(','),
-                onDelete: this.normalizeReferentialAction(row.delete_rule),
-                onUpdate: this.normalizeReferentialAction(row.update_rule)
-            }));
-    }
-    async getPrimaryKey(querier, tableName) {
-        const sql = `
-      SELECT COLUMN_NAME as column_name
-      FROM information_schema.KEY_COLUMN_USAGE
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-        AND CONSTRAINT_NAME = 'PRIMARY'
-      ORDER BY ORDINAL_POSITION
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        if (results.length === 0) {
-            return undefined;
-        }
-        return results.map((r)=>r.column_name);
-    }
-    parseDefaultValue(defaultValue) {
-        if (defaultValue === null) {
-            return undefined;
-        }
-        // Check for common patterns
-        if (defaultValue === 'NULL') {
-            return null;
-        }
-        if (defaultValue === 'CURRENT_TIMESTAMP') {
-            return defaultValue;
-        }
-        if (/^'.*'$/.test(defaultValue)) {
-            return defaultValue.slice(1, -1);
-        }
-        if (/^-?\d+$/.test(defaultValue)) {
-            return Number.parseInt(defaultValue, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(defaultValue)) {
-            return Number.parseFloat(defaultValue);
-        }
-        return defaultValue;
-    }
-    normalizeReferentialAction(action) {
-        switch(action.toUpperCase()){
-            case 'CASCADE':
-                return 'CASCADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            default:
-                return undefined;
-        }
+let _UserWithNonUpdatableId;
+_dec20 = Entity(), _dec21 = Id({
+    updatable: false
+}), _dec22 = Field();
+class UserWithNonUpdatableId {
+    static{
+        ({ e: [_init_id1, _init_name2], c: [_UserWithNonUpdatableId, _initClass3] } = _apply_decs_2203_r(this, [
+            [
+                _dec21,
+                0,
+                "id"
+            ],
+            [
+                _dec22,
+                0,
+                "name"
+            ]
+        ], [
+            _dec20
+        ]));
+    }
+    static{
+        _initClass3();
+    }
+    constructor(){
+        this.id = _init_id1(this);
+        this.name = _init_name2(this);
     }
 }
-/**
- * Alias for MysqlSchemaIntrospector.
- * MariaDB uses the same information_schema structure as MySQL.
- */ const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
-
-/**
- * PostgreSQL schema introspector
- */ class PostgresSchemaIntrospector {
-    constructor(pool){
-        this.pool = pool;
-    }
-    async getTableSchema(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            const exists = await this.tableExistsInternal(querier, tableName);
-            if (!exists) {
-                return undefined;
-            }
-            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
-                this.getColumns(querier, tableName),
-                this.getIndexes(querier, tableName),
-                this.getForeignKeys(querier, tableName),
-                this.getPrimaryKey(querier, tableName)
-            ]);
-            return {
-                name: tableName,
-                columns,
-                primaryKey,
-                indexes,
-                foreignKeys
-            };
-        } finally{
-            await querier.release();
-        }
-    }
-    async getTableNames() {
-        const querier = await this.getQuerier();
-        try {
-            const sql = `
-        SELECT table_name
-        FROM information_schema.tables
-        WHERE table_schema = 'public'
-          AND table_type = 'BASE TABLE'
-        ORDER BY table_name
-      `;
-            const results = await querier.all(sql);
-            return results.map((r)=>r.table_name);
-        } finally{
-            await querier.release();
-        }
+let _LedgerAccount;
+_dec23 = Entity(), _dec24 = Field(), _dec25 = Field(), _dec26 = Field({
+    reference: ()=>_LedgerAccount
+}), _dec27 = ManyToOne();
+class LedgerAccount extends (_BaseEntity3 = BaseEntity) {
+    static{
+        ({ e: [_init_name3, _init_description1, _init_parentLedgerId, _init_parentLedger], c: [_LedgerAccount, _initClass4] } = _apply_decs_2203_r(this, [
+            [
+                _dec24,
+                0,
+                "name"
+            ],
+            [
+                _dec25,
+                0,
+                "description"
+            ],
+            [
+                _dec26,
+                0,
+                "parentLedgerId"
+            ],
+            [
+                _dec27,
+                0,
+                "parentLedger"
+            ]
+        ], [
+            _dec23
+        ], _BaseEntity3));
+    }
+    static{
+        _initClass4();
     }
-    async tableExists(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            return this.tableExistsInternal(querier, tableName);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExistsInternal(querier, tableName) {
-        const sql = `
-      SELECT EXISTS (
-        SELECT FROM information_schema.tables
-        WHERE table_schema = 'public'
-          AND table_name = $1
-      ) AS exists
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results[0]?.exists ?? false;
-    }
-    async getQuerier() {
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('PostgresSchemaIntrospector requires a SQL-based querier');
-        }
-        return querier;
-    }
-    async getColumns(querier, tableName) {
-        const sql = /*sql*/ `
-      SELECT
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.is_nullable,
-        c.column_default,
-        c.character_maximum_length,
-        c.numeric_precision,
-        c.numeric_scale,
-        COALESCE(
-          (SELECT TRUE FROM information_schema.table_constraints tc
-           JOIN information_schema.key_column_usage kcu
-             ON tc.constraint_name = kcu.constraint_name
-           WHERE tc.table_name = c.table_name
-             AND tc.constraint_type = 'PRIMARY KEY'
-             AND kcu.column_name = c.column_name
-           LIMIT 1),
-          FALSE
-        ) AS is_primary_key,
-        COALESCE(
-          (SELECT TRUE FROM information_schema.table_constraints tc
-           JOIN information_schema.key_column_usage kcu
-             ON tc.constraint_name = kcu.constraint_name
-           WHERE tc.table_name = c.table_name
-             AND tc.constraint_type = 'UNIQUE'
-             AND kcu.column_name = c.column_name
-           LIMIT 1),
-          FALSE
-        ) AS is_unique,
-        pg_catalog.col_description(
-          (SELECT oid FROM pg_catalog.pg_class WHERE relname = c.table_name),
-          c.ordinal_position
-        ) AS column_comment
-      FROM information_schema.columns c
-      WHERE c.table_schema = 'public'
-        AND c.table_name = $1
-      ORDER BY c.ordinal_position
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.column_name,
-                type: this.normalizeType(row.data_type, row.udt_name),
-                nullable: row.is_nullable === 'YES',
-                defaultValue: this.parseDefaultValue(row.column_default),
-                isPrimaryKey: row.is_primary_key,
-                isAutoIncrement: this.isAutoIncrement(row.column_default),
-                isUnique: row.is_unique,
-                length: row.character_maximum_length ?? undefined,
-                precision: row.numeric_precision ?? undefined,
-                scale: row.numeric_scale ?? undefined,
-                comment: row.column_comment ?? undefined
-            }));
-    }
-    async getIndexes(querier, tableName) {
-        const sql = /*sql*/ `
-      SELECT
-        i.relname AS index_name,
-        array_agg(a.attname ORDER BY k.n) AS columns,
-        ix.indisunique AS is_unique
-      FROM pg_class t
-      JOIN pg_index ix ON t.oid = ix.indrelid
-      JOIN pg_class i ON i.oid = ix.indexrelid
-      JOIN pg_namespace n ON n.oid = t.relnamespace
-      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
-      WHERE t.relname = $1
-        AND n.nspname = 'public'
-        AND NOT ix.indisprimary
-      GROUP BY i.relname, ix.indisunique
-      ORDER BY i.relname
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.index_name,
-                columns: row.columns,
-                unique: row.is_unique
-            }));
-    }
-    async getForeignKeys(querier, tableName) {
-        const sql = /*sql*/ `
-      SELECT
-        tc.constraint_name,
-        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns,
-        ccu.table_name AS referenced_table,
-        array_agg(ccu.column_name ORDER BY kcu.ordinal_position) AS referenced_columns,
-        rc.delete_rule,
-        rc.update_rule
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      JOIN information_schema.constraint_column_usage ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-      JOIN information_schema.referential_constraints rc
-        ON rc.constraint_name = tc.constraint_name
-        AND rc.constraint_schema = tc.table_schema
-      WHERE tc.constraint_type = 'FOREIGN KEY'
-        AND tc.table_name = $1
-        AND tc.table_schema = 'public'
-      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
-      ORDER BY tc.constraint_name
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return results.map((row)=>({
-                name: row.constraint_name,
-                columns: row.columns,
-                referencedTable: row.referenced_table,
-                referencedColumns: row.referenced_columns,
-                onDelete: this.normalizeReferentialAction(row.delete_rule),
-                onUpdate: this.normalizeReferentialAction(row.update_rule)
-            }));
-    }
-    async getPrimaryKey(querier, tableName) {
-        const sql = /*sql*/ `
-      SELECT kcu.column_name
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-      WHERE tc.constraint_type = 'PRIMARY KEY'
-        AND tc.table_name = $1
-        AND tc.table_schema = 'public'
-      ORDER BY kcu.ordinal_position
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        if (results.length === 0) {
-            return undefined;
-        }
-        return results.map((r)=>r.column_name);
-    }
-    normalizeType(dataType, udtName) {
-        // Handle user-defined types and arrays
-        if (dataType === 'USER-DEFINED') {
-            return udtName.toUpperCase();
-        }
-        if (dataType === 'ARRAY') {
-            return `${udtName.replace(/^_/, '')}[]`;
-        }
-        return dataType.toUpperCase();
-    }
-    parseDefaultValue(defaultValue) {
-        if (!defaultValue) {
-            return undefined;
-        }
-        // Remove type casting
-        const cleaned = defaultValue.replace(/::[a-z_]+(\[\])?/gi, '').trim();
-        // Check for common patterns
-        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
-            return cleaned.slice(1, -1);
-        }
-        if (cleaned === 'true' || cleaned === 'false') {
-            return cleaned === 'true';
-        }
-        if (cleaned === 'NULL') {
-            return null;
-        }
-        if (/^-?\d+$/.test(cleaned)) {
-            return Number.parseInt(cleaned, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(cleaned)) {
-            return Number.parseFloat(cleaned);
-        }
-        // Return as-is for functions like CURRENT_TIMESTAMP, nextval(), etc.
-        return defaultValue;
-    }
-    isAutoIncrement(defaultValue) {
-        if (!defaultValue) {
-            return false;
-        }
-        return defaultValue.includes('nextval(');
-    }
-    normalizeReferentialAction(action) {
-        switch(action.toUpperCase()){
-            case 'CASCADE':
-                return 'CASCADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            default:
-                return undefined;
-        }
+    constructor(...args){
+        super(...args), this.name = _init_name3(this), this.description = _init_description1(this), this.parentLedgerId = _init_parentLedgerId(this), this.parentLedger = _init_parentLedger(this);
     }
 }
-
-/**
- * SQLite schema introspector
- */ class SqliteSchemaIntrospector {
-    constructor(pool){
-        this.pool = pool;
+let _TaxCategory;
+_dec28 = Entity(), _dec29 = Id({
+    onInsert: randomUUID
+}), _dec30 = Field(), _dec31 = Field();
+class TaxCategory extends (_BaseEntity4 = BaseEntity) {
+    static{
+        ({ e: [_init_pk1, _init_name4, _init_description2], c: [_TaxCategory, _initClass5] } = _apply_decs_2203_r(this, [
+            [
+                _dec29,
+                0,
+                "pk"
+            ],
+            [
+                _dec30,
+                0,
+                "name"
+            ],
+            [
+                _dec31,
+                0,
+                "description"
+            ]
+        ], [
+            _dec28
+        ], _BaseEntity4));
+    }
+    static{
+        _initClass5();
     }
-    async getTableSchema(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            const exists = await this.tableExistsInternal(querier, tableName);
-            if (!exists) {
-                return undefined;
-            }
-            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
-                this.getColumns(querier, tableName),
-                this.getIndexes(querier, tableName),
-                this.getForeignKeys(querier, tableName),
-                this.getPrimaryKey(querier, tableName)
-            ]);
-            return {
-                name: tableName,
-                columns,
-                primaryKey,
-                indexes,
-                foreignKeys
-            };
-        } finally{
-            await querier.release();
-        }
-    }
-    async getTableNames() {
-        const querier = await this.getQuerier();
-        try {
-            const sql = /*sql*/ `
-        SELECT name
-        FROM sqlite_master
-        WHERE type = 'table'
-          AND name NOT LIKE 'sqlite_%'
-        ORDER BY name
-      `;
-            const results = await querier.all(sql);
-            return results.map((r)=>r.name);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExists(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            return this.tableExistsInternal(querier, tableName);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExistsInternal(querier, tableName) {
-        const sql = /*sql*/ `
-      SELECT COUNT(*) as count
-      FROM sqlite_master
-      WHERE type = 'table'
-        AND name = ?
-    `;
-        const results = await querier.all(sql, [
-            tableName
-        ]);
-        return (results[0]?.count ?? 0) > 0;
-    }
-    async getQuerier() {
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('SqliteSchemaIntrospector requires a SQL-based querier');
-        }
-        return querier;
-    }
-    async getColumns(querier, tableName) {
-        // SQLite uses PRAGMA for table info
-        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
-        const results = await querier.all(sql);
-        // Get unique columns from indexes
-        const uniqueColumns = await this.getUniqueColumns(querier, tableName);
-        return results.map((row)=>({
-                name: row.name,
-                type: this.normalizeType(row.type),
-                nullable: row.notnull === 0,
-                defaultValue: this.parseDefaultValue(row.dflt_value),
-                isPrimaryKey: row.pk > 0,
-                isAutoIncrement: row.pk > 0 && row.type.toUpperCase() === 'INTEGER',
-                isUnique: uniqueColumns.has(row.name),
-                length: this.extractLength(row.type),
-                precision: undefined,
-                scale: undefined,
-                comment: undefined
-            }));
-    }
-    async getUniqueColumns(querier, tableName) {
-        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
-        const indexes = await querier.all(sql);
-        const uniqueColumns = new Set();
-        for (const index of indexes){
-            if (index.unique && index.origin === 'u') {
-                const indexInfo = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
-                // Only single-column unique constraints
-                if (indexInfo.length === 1) {
-                    uniqueColumns.add(indexInfo[0].name);
-                }
-            }
-        }
-        return uniqueColumns;
+    constructor(...args){
+        super(...args), this.pk = _init_pk1(this), this.name = _init_name4(this), this.description = _init_description2(this);
     }
-    async getIndexes(querier, tableName) {
-        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
-        const indexes = await querier.all(sql);
-        const result = [];
-        for (const index of indexes){
-            // Skip auto-generated indexes (primary key, unique constraints)
-            if (index.origin !== 'c') {
-                continue;
-            }
-            const columns = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
-            result.push({
-                name: index.name,
-                columns: columns.map((c)=>c.name),
-                unique: Boolean(index.unique)
-            });
-        }
-        return result;
+}
+let _Tax;
+_dec32 = Entity(), _dec33 = Field(), _dec34 = Field(), _dec35 = Field({
+    reference: ()=>_TaxCategory
+}), _dec36 = ManyToOne(), _dec37 = Field();
+class Tax extends (_BaseEntity5 = BaseEntity) {
+    static{
+        ({ e: [_init_name5, _init_percentage, _init_categoryId, _init_category, _init_description3], c: [_Tax, _initClass6] } = _apply_decs_2203_r(this, [
+            [
+                _dec33,
+                0,
+                "name"
+            ],
+            [
+                _dec34,
+                0,
+                "percentage"
+            ],
+            [
+                _dec35,
+                0,
+                "categoryId"
+            ],
+            [
+                _dec36,
+                0,
+                "category"
+            ],
+            [
+                _dec37,
+                0,
+                "description"
+            ]
+        ], [
+            _dec32
+        ], _BaseEntity5));
+    }
+    static{
+        _initClass6();
     }
-    async getForeignKeys(querier, tableName) {
-        const sql = `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
-        const results = await querier.all(sql);
-        // Group by id to handle composite foreign keys
-        const grouped = new Map();
-        for (const row of results){
-            const existing = grouped.get(row.id) ?? [];
-            existing.push(row);
-            grouped.set(row.id, existing);
-        }
-        return Array.from(grouped.entries()).map(([id, rows])=>{
-            const first = rows[0];
-            return {
-                name: `fk_${tableName}_${id}`,
-                columns: rows.map((r)=>r.from),
-                referencedTable: first.table,
-                referencedColumns: rows.map((r)=>r.to),
-                onDelete: this.normalizeReferentialAction(first.on_delete),
-                onUpdate: this.normalizeReferentialAction(first.on_update)
-            };
-        });
+    constructor(...args){
+        super(...args), this.name = _init_name5(this), this.percentage = _init_percentage(this), this.categoryId = _init_categoryId(this), this.category = _init_category(this), this.description = _init_description3(this);
     }
-    async getPrimaryKey(querier, tableName) {
-        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
-        const results = await querier.all(sql);
-        const pkColumns = results.filter((r)=>r.pk > 0).sort((a, b)=>a.pk - b.pk);
-        if (pkColumns.length === 0) {
-            return undefined;
-        }
-        return pkColumns.map((r)=>r.name);
+}
+let _MeasureUnitCategory;
+_dec38 = Entity({
+    softDelete: true
+}), _dec39 = Field(), _dec40 = OneToMany({
+    entity: ()=>_MeasureUnit,
+    mappedBy: (measureUnit)=>measureUnit.categoryId
+}), _dec41 = Field({
+    onDelete: Date.now
+});
+class MeasureUnitCategory extends (_BaseEntity6 = BaseEntity) {
+    static{
+        ({ e: [_init_name6, _init_measureUnits, _init_deletedAt], c: [_MeasureUnitCategory, _initClass7] } = _apply_decs_2203_r(this, [
+            [
+                _dec39,
+                0,
+                "name"
+            ],
+            [
+                _dec40,
+                0,
+                "measureUnits"
+            ],
+            [
+                _dec41,
+                0,
+                "deletedAt"
+            ]
+        ], [
+            _dec38
+        ], _BaseEntity6));
+    }
+    static{
+        _initClass7();
     }
-    escapeId(identifier) {
-        return `\`${identifier.replace(/`/g, '``')}\``;
+    constructor(...args){
+        super(...args), this.name = _init_name6(this), this.measureUnits = _init_measureUnits(this), this.deletedAt = _init_deletedAt(this);
     }
-    normalizeType(type) {
-        // Extract base type without length/precision
-        const match = type.match(/^([A-Za-z]+)/);
-        return match ? match[1].toUpperCase() : type.toUpperCase();
+}
+let _MeasureUnit;
+_dec42 = Entity({
+    softDelete: true
+}), _dec43 = Field(), _dec44 = Field({
+    reference: ()=>_MeasureUnitCategory
+}), _dec45 = ManyToOne({
+    cascade: 'persist'
+}), _dec46 = Field({
+    onDelete: Date.now
+});
+class MeasureUnit extends (_BaseEntity7 = BaseEntity) {
+    static{
+        ({ e: [_init_name7, _init_categoryId1, _init_category1, _init_deletedAt1], c: [_MeasureUnit, _initClass8] } = _apply_decs_2203_r(this, [
+            [
+                _dec43,
+                0,
+                "name"
+            ],
+            [
+                _dec44,
+                0,
+                "categoryId"
+            ],
+            [
+                _dec45,
+                0,
+                "category"
+            ],
+            [
+                _dec46,
+                0,
+                "deletedAt"
+            ]
+        ], [
+            _dec42
+        ], _BaseEntity7));
+    }
+    static{
+        _initClass8();
     }
-    extractLength(type) {
-        const match = type.match(/\((\d+)\)/);
-        return match ? Number.parseInt(match[1], 10) : undefined;
+    constructor(...args){
+        super(...args), this.name = _init_name7(this), this.categoryId = _init_categoryId1(this), this.category = _init_category1(this), this.deletedAt = _init_deletedAt1(this);
     }
-    parseDefaultValue(defaultValue) {
-        if (defaultValue === null) {
-            return undefined;
-        }
-        // Check for common patterns
-        if (defaultValue === 'NULL') {
-            return null;
-        }
-        if (defaultValue === 'CURRENT_TIMESTAMP' || defaultValue === 'CURRENT_DATE' || defaultValue === 'CURRENT_TIME') {
-            return defaultValue;
-        }
-        if (/^'.*'$/.test(defaultValue)) {
-            return defaultValue.slice(1, -1);
-        }
-        if (/^-?\d+$/.test(defaultValue)) {
-            return Number.parseInt(defaultValue, 10);
-        }
-        if (/^-?\d+\.\d+$/.test(defaultValue)) {
-            return Number.parseFloat(defaultValue);
-        }
-        return defaultValue;
+}
+let _Storehouse;
+_dec47 = Entity(), _dec48 = Field(), _dec49 = Field(), _dec50 = Field();
+class Storehouse extends (_BaseEntity8 = BaseEntity) {
+    static{
+        ({ e: [_init_name8, _init_address, _init_description4], c: [_Storehouse, _initClass9] } = _apply_decs_2203_r(this, [
+            [
+                _dec48,
+                0,
+                "name"
+            ],
+            [
+                _dec49,
+                0,
+                "address"
+            ],
+            [
+                _dec50,
+                0,
+                "description"
+            ]
+        ], [
+            _dec47
+        ], _BaseEntity8));
+    }
+    static{
+        _initClass9();
     }
-    normalizeReferentialAction(action) {
-        switch(action.toUpperCase()){
-            case 'CASCADE':
-                return 'CASCADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            default:
-                return undefined;
-        }
+    constructor(...args){
+        super(...args), this.name = _init_name8(this), this.address = _init_address(this), this.description = _init_description4(this);
     }
 }
-
-class MongoSchemaGenerator extends AbstractDialect {
-    generateCreateTable(entity) {
-        const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
-        const indexes = [];
-        for(const key in meta.fields){
-            const field = meta.fields[key];
-            if (field.index) {
-                const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
-                indexes.push({
-                    name: indexName,
-                    columns: [
-                        columnName
-                    ],
-                    unique: !!field.unique
-                });
-            }
-        }
-        return JSON.stringify({
-            action: 'createCollection',
-            name: collectionName,
-            indexes
+let _Item;
+_dec51 = Entity(), _dec52 = Field(), _dec53 = Field(), _dec54 = Field(), _dec55 = Field({
+    reference: ()=>_LedgerAccount
+}), _dec56 = ManyToOne(), _dec57 = Field({
+    reference: ()=>_LedgerAccount
+}), _dec58 = ManyToOne(), _dec59 = Field({
+    reference: ()=>_Tax
+}), _dec60 = ManyToOne(), _dec61 = Field({
+    reference: ()=>_MeasureUnit
+}), _dec62 = ManyToOne(), _dec63 = Field(), _dec64 = Field(), _dec65 = ManyToMany({
+    entity: ()=>_Tag,
+    through: ()=>_ItemTag,
+    cascade: true
+}), _dec66 = Field({
+    /**
+     * `virtual` property allows defining the value for a non-persistent field,
+     * such value might be a scalar or a (`raw`) function. Virtual-fields can
+     * be used in `$select` and `$where` as a common field whose value is
+     * replaced is replaced at runtime.
+     */ virtual: raw(({ ctx, escapedPrefix, dialect })=>{
+        ctx.append('(');
+        dialect.count(ctx, _ItemTag, {
+            $where: {
+                itemId: raw(({ ctx })=>{
+                    ctx.append(escapedPrefix + dialect.escapeId('id'));
+                })
+            }
+        }, {
+            autoPrefix: true
         });
+        ctx.append(')');
+    })
+});
+class Item extends (_BaseEntity9 = BaseEntity) {
+    static{
+        ({ e: [_init_name9, _init_description5, _init_code, _init_buyLedgerAccountId, _init_buyLedgerAccount, _init_saleLedgerAccountId, _init_saleLedgerAccount, _init_taxId, _init_tax, _init_measureUnitId, _init_measureUnit, _init_salePrice, _init_inventoryable, _init_tags, _init_tagsCount], c: [_Item, _initClass10] } = _apply_decs_2203_r(this, [
+            [
+                _dec52,
+                0,
+                "name"
+            ],
+            [
+                _dec53,
+                0,
+                "description"
+            ],
+            [
+                _dec54,
+                0,
+                "code"
+            ],
+            [
+                _dec55,
+                0,
+                "buyLedgerAccountId"
+            ],
+            [
+                _dec56,
+                0,
+                "buyLedgerAccount"
+            ],
+            [
+                _dec57,
+                0,
+                "saleLedgerAccountId"
+            ],
+            [
+                _dec58,
+                0,
+                "saleLedgerAccount"
+            ],
+            [
+                _dec59,
+                0,
+                "taxId"
+            ],
+            [
+                _dec60,
+                0,
+                "tax"
+            ],
+            [
+                _dec61,
+                0,
+                "measureUnitId"
+            ],
+            [
+                _dec62,
+                0,
+                "measureUnit"
+            ],
+            [
+                _dec63,
+                0,
+                "salePrice"
+            ],
+            [
+                _dec64,
+                0,
+                "inventoryable"
+            ],
+            [
+                _dec65,
+                0,
+                "tags"
+            ],
+            [
+                _dec66,
+                0,
+                "tagsCount"
+            ]
+        ], [
+            _dec51
+        ], _BaseEntity9));
+    }
+    static{
+        _initClass10();
     }
-    generateDropTable(entity) {
-        const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
-        return JSON.stringify({
-            action: 'dropCollection',
-            name: collectionName
-        });
-    }
-    generateAlterTable(diff) {
-        const statements = [];
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd){
-                statements.push(this.generateCreateIndex(diff.tableName, index));
-            }
-        }
-        return statements;
-    }
-    generateAlterTableDown(diff) {
-        const statements = [];
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd){
-                statements.push(this.generateDropIndex(diff.tableName, index.name));
-            }
-        }
-        return statements;
-    }
-    generateCreateIndex(tableName, index) {
-        const key = {};
-        for (const col of index.columns){
-            key[col] = 1;
-        }
-        return JSON.stringify({
-            action: 'createIndex',
-            collection: tableName,
-            name: index.name,
-            key,
-            options: {
-                unique: index.unique,
-                name: index.name
-            }
-        });
+    constructor(...args){
+        super(...args), this.name = _init_name9(this), this.description = _init_description5(this), this.code = _init_code(this), this.buyLedgerAccountId = _init_buyLedgerAccountId(this), this.buyLedgerAccount = _init_buyLedgerAccount(this), this.saleLedgerAccountId = _init_saleLedgerAccountId(this), this.saleLedgerAccount = _init_saleLedgerAccount(this), this.taxId = _init_taxId(this), this.tax = _init_tax(this), this.measureUnitId = _init_measureUnitId(this), this.measureUnit = _init_measureUnit(this), this.salePrice = _init_salePrice(this), this.inventoryable = _init_inventoryable(this), this.tags = _init_tags(this), this.tagsCount = _init_tagsCount(this);
     }
-    generateDropIndex(tableName, indexName) {
-        return JSON.stringify({
-            action: 'dropIndex',
-            collection: tableName,
-            name: indexName
+}
+let _Tag;
+_dec67 = Entity(), _dec68 = Field(), _dec69 = ManyToMany({
+    entity: ()=>_Item,
+    mappedBy: (item)=>item.tags
+}), _dec70 = Field({
+    virtual: raw(({ ctx, escapedPrefix, dialect })=>{
+        ctx.append('(');
+        dialect.count(ctx, _ItemTag, {
+            $where: {
+                tagId: raw(({ ctx })=>{
+                    ctx.append(escapedPrefix + dialect.escapeId('id'));
+                })
+            }
+        }, {
+            autoPrefix: true
         });
+        ctx.append(')');
+    })
+});
+class Tag extends (_BaseEntity10 = BaseEntity) {
+    static{
+        ({ e: [_init_name10, _init_items, _init_itemsCount], c: [_Tag, _initClass11] } = _apply_decs_2203_r(this, [
+            [
+                _dec68,
+                0,
+                "name"
+            ],
+            [
+                _dec69,
+                0,
+                "items"
+            ],
+            [
+                _dec70,
+                0,
+                "itemsCount"
+            ]
+        ], [
+            _dec67
+        ], _BaseEntity10));
+    }
+    static{
+        _initClass11();
     }
-    getSqlType() {
-        return '';
-    }
-    diffSchema(entity, currentSchema) {
-        const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
-        if (!currentSchema) {
-            return {
-                tableName: collectionName,
-                type: 'create'
-            };
-        }
-        const indexesToAdd = [];
-        const existingIndexes = new Set(currentSchema.indexes?.map((i)=>i.name) ?? []);
-        for(const key in meta.fields){
-            const field = meta.fields[key];
-            if (field.index) {
-                const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
-                if (!existingIndexes.has(indexName)) {
-                    indexesToAdd.push({
-                        name: indexName,
-                        columns: [
-                            columnName
-                        ],
-                        unique: !!field.unique
-                    });
-                }
-            }
-        }
-        if (indexesToAdd.length === 0) {
-            return undefined;
-        }
-        return {
-            tableName: collectionName,
-            type: 'alter',
-            indexesToAdd
-        };
+    constructor(...args){
+        super(...args), this.name = _init_name10(this), this.items = _init_items(this), this.itemsCount = _init_itemsCount(this);
     }
 }
-
-class MongoSchemaIntrospector {
-    constructor(pool){
-        this.pool = pool;
-    }
-    async getTableSchema(tableName) {
-        const querier = await this.pool.getQuerier();
-        try {
-            const { db } = querier;
-            const collections = await db.listCollections({
-                name: tableName
-            }).toArray();
-            if (collections.length === 0) {
-                return undefined;
-            }
-            // MongoDB doesn't have a fixed schema, but we can look at the indexes
-            const indexes = await db.collection(tableName).indexes();
-            return {
-                name: tableName,
-                columns: [],
-                indexes: indexes.map((idx)=>({
-                        name: idx.name,
-                        columns: Object.keys(idx.key),
-                        unique: !!idx.unique
-                    }))
-            };
-        } finally{
-            await querier.release();
-        }
-    }
-    async getTableNames() {
-        const querier = await this.pool.getQuerier();
-        try {
-            const { db } = querier;
-            const collections = await db.listCollections().toArray();
-            return collections.map((c)=>c.name);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExists(tableName) {
-        const names = await this.getTableNames();
-        return names.includes(tableName);
+let _ItemTag;
+_dec71 = Entity(), _dec72 = Id(), _dec73 = Field({
+    reference: ()=>_Item
+}), _dec74 = Field({
+    reference: ()=>_Tag
+});
+class ItemTag {
+    static{
+        ({ e: [_init_id2, _init_itemId, _init_tagId], c: [_ItemTag, _initClass12] } = _apply_decs_2203_r(this, [
+            [
+                _dec72,
+                0,
+                "id"
+            ],
+            [
+                _dec73,
+                0,
+                "itemId"
+            ],
+            [
+                _dec74,
+                0,
+                "tagId"
+            ]
+        ], [
+            _dec71
+        ]));
+    }
+    static{
+        _initClass12();
+    }
+    constructor(){
+        this.id = _init_id2(this);
+        this.itemId = _init_itemId(this);
+        this.tagId = _init_tagId(this);
     }
 }
-
-/**
- * Stores migration state in a database table.
- * Uses the querier's dialect for escaping and placeholders.
- */ class DatabaseMigrationStorage {
-    constructor(pool, options = {}){
-        this.pool = pool;
-        this.storageInitialized = false;
-        this.tableName = options.tableName ?? 'uql_migrations';
-    }
-    async ensureStorage() {
-        if (this.storageInitialized) {
-            return;
-        }
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
-        }
-        try {
-            await this.createTableIfNotExists(querier);
-            this.storageInitialized = true;
-        } finally{
-            await querier.release();
-        }
+let _InventoryAdjustment;
+_dec75 = Entity(), _dec76 = OneToMany({
+    entity: ()=>_ItemAdjustment,
+    mappedBy: (rel)=>rel.inventoryAdjustment,
+    cascade: true
+}), _dec77 = Field(), _dec78 = Field();
+class InventoryAdjustment extends (_BaseEntity11 = BaseEntity) {
+    static{
+        ({ e: [_init_itemAdjustments, _init_date, _init_description6], c: [_InventoryAdjustment, _initClass13] } = _apply_decs_2203_r(this, [
+            [
+                _dec76,
+                0,
+                "itemAdjustments"
+            ],
+            [
+                _dec77,
+                0,
+                "date"
+            ],
+            [
+                _dec78,
+                0,
+                "description"
+            ]
+        ], [
+            _dec75
+        ], _BaseEntity11));
+    }
+    static{
+        _initClass13();
     }
-    async createTableIfNotExists(querier) {
-        const { escapeId } = querier.dialect;
-        const sql = `
-      CREATE TABLE IF NOT EXISTS ${escapeId(this.tableName)} (
-        ${escapeId('name')} VARCHAR(255) PRIMARY KEY,
-        ${escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-        await querier.run(sql);
-    }
-    async executed() {
-        await this.ensureStorage();
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
-        }
-        try {
-            const { escapeId } = querier.dialect;
-            const sql = `SELECT ${escapeId('name')} FROM ${escapeId(this.tableName)} ORDER BY ${escapeId('name')} ASC`;
-            const results = await querier.all(sql);
-            return results.map((r)=>r.name);
-        } finally{
-            await querier.release();
-        }
+    constructor(...args){
+        super(...args), this.itemAdjustments = _init_itemAdjustments(this), this.date = _init_date(this), this.description = _init_description6(this);
     }
-    /**
-   * Log a migration as executed - uses provided querier (within transaction)
-   */ async logWithQuerier(querier, migrationName) {
-        await this.ensureStorage();
-        const { escapeId, placeholder } = querier.dialect;
-        const sql = `INSERT INTO ${escapeId(this.tableName)} (${escapeId('name')}) VALUES (${placeholder(1)})`;
-        await querier.run(sql, [
-            migrationName
-        ]);
+}
+let _ItemAdjustment;
+_dec79 = Entity(), _dec80 = Field({
+    reference: ()=>_Item
+}), _dec81 = ManyToOne(), _dec82 = Field(), _dec83 = Field(), _dec84 = Field({
+    reference: ()=>_Storehouse
+}), _dec85 = ManyToOne(), _dec86 = Field({
+    reference: ()=>_InventoryAdjustment
+}), _dec87 = ManyToOne();
+class ItemAdjustment extends (_BaseEntity12 = BaseEntity) {
+    static{
+        ({ e: [_init_itemId1, _init_item, _init_number, _init_buyPrice, _init_storehouseId, _init_storehouse, _init_inventoryAdjustmentId, _init_inventoryAdjustment], c: [_ItemAdjustment, _initClass14] } = _apply_decs_2203_r(this, [
+            [
+                _dec80,
+                0,
+                "itemId"
+            ],
+            [
+                _dec81,
+                0,
+                "item"
+            ],
+            [
+                _dec82,
+                0,
+                "number"
+            ],
+            [
+                _dec83,
+                0,
+                "buyPrice"
+            ],
+            [
+                _dec84,
+                0,
+                "storehouseId"
+            ],
+            [
+                _dec85,
+                0,
+                "storehouse"
+            ],
+            [
+                _dec86,
+                0,
+                "inventoryAdjustmentId"
+            ],
+            [
+                _dec87,
+                0,
+                "inventoryAdjustment"
+            ]
+        ], [
+            _dec79
+        ], _BaseEntity12));
+    }
+    static{
+        _initClass14();
     }
-    /**
-   * Unlog a migration - uses provided querier (within transaction)
-   */ async unlogWithQuerier(querier, migrationName) {
-        await this.ensureStorage();
-        const { escapeId, placeholder } = querier.dialect;
-        const sql = `DELETE FROM ${escapeId(this.tableName)} WHERE ${escapeId('name')} = ${placeholder(1)}`;
-        await querier.run(sql, [
-            migrationName
-        ]);
+    constructor(...args){
+        super(...args), this.itemId = _init_itemId1(this), this.item = _init_item(this), this.number = _init_number(this), this.buyPrice = _init_buyPrice(this), this.storehouseId = _init_storehouseId(this), this.storehouse = _init_storehouse(this), this.inventoryAdjustmentId = _init_inventoryAdjustmentId(this), this.inventoryAdjustment = _init_inventoryAdjustment(this);
     }
 }
 
-/**
- * Main class for managing database migrations
- */ class Migrator {
-    constructor(pool, options = {}){
-        this.pool = pool;
-        this.dialect = options.dialect ?? pool.dialect ?? 'postgres';
-        this.storage = options.storage ?? new DatabaseMigrationStorage(pool, {
-            tableName: options.tableName
-        });
-        this.migrationsPath = options.migrationsPath ?? './migrations';
-        this.logger = options.logger ?? (()=>{});
-        this.entities = options.entities ?? [];
-        this.schemaIntrospector = this.createIntrospector();
-        this.schemaGenerator = options.schemaGenerator ?? this.createGenerator(options.namingStrategy);
-    }
-    /**
-   * Set the schema generator for DDL operations
-   */ setSchemaGenerator(generator) {
-        this.schemaGenerator = generator;
-    }
-    createIntrospector() {
-        switch(this.dialect){
-            case 'postgres':
-                return new PostgresSchemaIntrospector(this.pool);
-            case 'mysql':
-                return new MysqlSchemaIntrospector(this.pool);
-            case 'mariadb':
-                return new MariadbSchemaIntrospector(this.pool);
-            case 'sqlite':
-                return new SqliteSchemaIntrospector(this.pool);
-            case 'mongodb':
-                return new MongoSchemaIntrospector(this.pool);
-            default:
-                return undefined;
-        }
-    }
-    createGenerator(namingStrategy) {
-        switch(this.dialect){
-            case 'postgres':
-                return new PostgresSchemaGenerator(namingStrategy);
-            case 'mysql':
-                return new MysqlSchemaGenerator(namingStrategy);
-            case 'mariadb':
-                return new MysqlSchemaGenerator(namingStrategy);
-            case 'sqlite':
-                return new SqliteSchemaGenerator(namingStrategy);
-            case 'mongodb':
-                return new MongoSchemaGenerator(namingStrategy);
-            default:
-                return undefined;
-        }
-    }
-    /**
-   * Get the SQL dialect
-   */ getDialect() {
-        return this.dialect;
-    }
-    /**
-   * Get all discovered migrations from the migrations directory
-   */ async getMigrations() {
-        const files = await this.getMigrationFiles();
-        const migrations = [];
-        for (const file of files){
-            const migration = await this.loadMigration(file);
-            if (migration) {
-                migrations.push(migration);
-            }
-        }
-        // Sort by name (which typically includes timestamp)
-        return migrations.sort((a, b)=>a.name.localeCompare(b.name));
-    }
-    /**
-   * Get list of pending migrations (not yet executed)
-   */ async pending() {
-        const [migrations, executed] = await Promise.all([
-            this.getMigrations(),
-            this.storage.executed()
-        ]);
-        const executedSet = new Set(executed);
-        return migrations.filter((m)=>!executedSet.has(m.name));
-    }
-    /**
-   * Get list of executed migrations
-   */ async executed() {
-        return this.storage.executed();
-    }
-    /**
-   * Run all pending migrations
-   */ async up(options = {}) {
-        const pendingMigrations = await this.pending();
-        const results = [];
-        let migrationsToRun = pendingMigrations;
-        if (options.to) {
-            const toIndex = migrationsToRun.findIndex((m)=>m.name === options.to);
-            if (toIndex === -1) {
-                throw new Error(`Migration '${options.to}' not found`);
-            }
-            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
-        }
-        if (options.step !== undefined) {
-            migrationsToRun = migrationsToRun.slice(0, options.step);
-        }
-        for (const migration of migrationsToRun){
-            const result = await this.runMigration(migration, 'up');
-            results.push(result);
-            if (!result.success) {
-                break; // Stop on first failure
-            }
-        }
-        return results;
-    }
-    /**
-   * Rollback migrations
-   */ async down(options = {}) {
-        const [migrations, executed] = await Promise.all([
-            this.getMigrations(),
-            this.storage.executed()
-        ]);
-        const executedSet = new Set(executed);
-        const executedMigrations = migrations.filter((m)=>executedSet.has(m.name)).reverse(); // Rollback in reverse order
-        const results = [];
-        let migrationsToRun = executedMigrations;
-        if (options.to) {
-            const toIndex = migrationsToRun.findIndex((m)=>m.name === options.to);
-            if (toIndex === -1) {
-                throw new Error(`Migration '${options.to}' not found`);
-            }
-            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
-        }
-        if (options.step !== undefined) {
-            migrationsToRun = migrationsToRun.slice(0, options.step);
-        }
-        for (const migration of migrationsToRun){
-            const result = await this.runMigration(migration, 'down');
-            results.push(result);
-            if (!result.success) {
-                break; // Stop on first failure
-            }
-        }
-        return results;
-    }
-    /**
-   * Run a single migration within a transaction
-   */ async runMigration(migration, direction) {
-        const startTime = Date.now();
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('Migrator requires a SQL-based querier');
-        }
-        try {
-            this.logger(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);
-            await querier.beginTransaction();
-            if (direction === 'up') {
-                await migration.up(querier);
-                // Log within the same transaction
-                await this.storage.logWithQuerier(querier, migration.name);
-            } else {
-                await migration.down(querier);
-                // Unlog within the same transaction
-                await this.storage.unlogWithQuerier(querier, migration.name);
-            }
-            await querier.commitTransaction();
-            const duration = Date.now() - startTime;
-            this.logger(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);
-            return {
-                name: migration.name,
-                direction,
-                duration,
-                success: true
-            };
-        } catch (error) {
-            await querier.rollbackTransaction();
-            const duration = Date.now() - startTime;
-            this.logger(`Migration ${migration.name} failed: ${error.message}`);
-            return {
-                name: migration.name,
-                direction,
-                duration,
-                success: false,
-                error: error
-            };
-        } finally{
-            await querier.release();
-        }
+const holder = globalThis;
+const metaKey = '@uql/core/entity/decorator';
+const metas = holder[metaKey] ?? new Map();
+holder[metaKey] = metas;
+function getEntities() {
+    return [
+        ...metas.entries()
+    ].reduce((acc, [key, val])=>{
+        if (val.id) {
+            acc.push(key);
+        }
+        return acc;
+    }, []);
+}
+function ensureMeta(entity) {
+    let meta = metas.get(entity);
+    if (meta) {
+        return meta;
+    }
+    meta = {
+        entity,
+        fields: {},
+        relations: {}
+    };
+    metas.set(entity, meta);
+    return meta;
+}
+function getMeta(entity) {
+    const meta = metas.get(entity);
+    if (!meta) {
+        throw TypeError(`'${entity.name}' is not an entity`);
     }
-    /**
-   * Generate a new migration file
-   */ async generate(name) {
-        const timestamp = this.getTimestamp();
-        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
-        const filePath = join(this.migrationsPath, fileName);
-        const content = this.generateMigrationContent(name);
-        const { writeFile, mkdir } = await import('node:fs/promises');
-        await mkdir(this.migrationsPath, {
-            recursive: true
-        });
-        await writeFile(filePath, content, 'utf-8');
-        this.logger(`Created migration: ${filePath}`);
-        return filePath;
+    if (meta.processed) {
+        return meta;
     }
-    /**
-   * Generate a migration based on entity schema differences
-   */ async generateFromEntities(name) {
-        if (!this.schemaGenerator) {
-            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
-        }
-        const diffs = await this.getDiffs();
-        const upStatements = [];
-        const downStatements = [];
-        for (const diff of diffs){
-            if (diff.type === 'create') {
-                const entity = this.findEntityForTable(diff.tableName);
-                if (entity) {
-                    upStatements.push(this.schemaGenerator.generateCreateTable(entity));
-                    downStatements.push(this.schemaGenerator.generateDropTable(entity));
+    meta.processed = true;
+    return fillRelations(meta);
+}
+function fillRelations(meta) {
+    for(const relKey in meta.relations){
+        const relOpts = meta.relations[relKey];
+        if (relOpts.references) {
+            continue;
+        }
+        if (relOpts.mappedBy) {
+            fillInverseSideRelations(relOpts);
+            continue;
+        }
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        if (relOpts.cardinality === 'mm') {
+            const idName = meta.fields[meta.id].name;
+            const relIdName = relMeta.fields[relMeta.id].name;
+            const source = lowerFirst(meta.name) + upperFirst(idName);
+            const target = lowerFirst(relMeta.name) + upperFirst(relIdName);
+            relOpts.references = [
+                {
+                    local: source,
+                    foreign: meta.id
+                },
+                {
+                    local: target,
+                    foreign: relMeta.id
                 }
-            } else if (diff.type === 'alter') {
-                const alterStatements = this.schemaGenerator.generateAlterTable(diff);
-                upStatements.push(...alterStatements);
-                const alterDownStatements = this.schemaGenerator.generateAlterTableDown(diff);
-                downStatements.push(...alterDownStatements);
-            }
-        }
-        if (upStatements.length === 0) {
-            this.logger('No schema changes detected.');
-            return '';
-        }
-        const timestamp = this.getTimestamp();
-        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
-        const filePath = join(this.migrationsPath, fileName);
-        const content = this.generateMigrationContentWithStatements(name, upStatements, downStatements.reverse());
-        const { writeFile, mkdir } = await import('node:fs/promises');
-        await mkdir(this.migrationsPath, {
-            recursive: true
-        });
-        await writeFile(filePath, content, 'utf-8');
-        this.logger(`Created migration from entities: ${filePath}`);
-        return filePath;
-    }
-    /**
-   * Get all schema differences between entities and database
-   */ async getDiffs() {
-        if (!this.schemaGenerator || !this.schemaIntrospector) {
-            throw new Error('Schema generator and introspector must be set');
-        }
-        const entities = this.entities.length > 0 ? this.entities : getEntities();
-        const diffs = [];
-        for (const entity of entities){
-            const meta = getMeta(entity);
-            const tableName = this.schemaGenerator.resolveTableName(entity, meta);
-            const currentSchema = await this.schemaIntrospector.getTableSchema(tableName);
-            const diff = this.schemaGenerator.diffSchema(entity, currentSchema);
-            if (diff) {
-                diffs.push(diff);
-            }
-        }
-        return diffs;
-    }
-    findEntityForTable(tableName) {
-        const entities = this.entities.length > 0 ? this.entities : getEntities();
-        for (const entity of entities){
-            const meta = getMeta(entity);
-            const name = this.schemaGenerator.resolveTableName(entity, meta);
-            if (name === tableName) {
-                return entity;
-            }
-        }
-        return undefined;
-    }
-    /**
-   * Sync schema directly (for development only - not for production!)
-   */ async sync(options = {}) {
-        if (options.force) {
-            return this.syncForce();
-        }
-        return this.autoSync({
-            safe: true
-        });
-    }
-    /**
-   * Drops and recreates all tables (Development only!)
-   */ async syncForce() {
-        if (!this.schemaGenerator) {
-            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
-        }
-        const entities = this.entities.length > 0 ? this.entities : getEntities();
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('Migrator requires a SQL-based querier');
-        }
-        try {
-            await querier.beginTransaction();
-            // Drop all tables first (in reverse order for foreign keys)
-            for (const entity of [
-                ...entities
-            ].reverse()){
-                const dropSql = this.schemaGenerator.generateDropTable(entity);
-                this.logger(`Executing: ${dropSql}`);
-                await querier.run(dropSql);
-            }
-            // Create all tables
-            for (const entity of entities){
-                const createSql = this.schemaGenerator.generateCreateTable(entity);
-                this.logger(`Executing: ${createSql}`);
-                await querier.run(createSql);
-            }
-            await querier.commitTransaction();
-            this.logger('Schema sync (force) completed');
-        } catch (error) {
-            await querier.rollbackTransaction();
-            throw error;
-        } finally{
-            await querier.release();
-        }
-    }
-    /**
-   * Safely synchronizes the schema by only adding missing tables and columns.
-   */ async autoSync(options = {}) {
-        if (!this.schemaGenerator || !this.schemaIntrospector) {
-            throw new Error('Schema generator and introspector must be set');
-        }
-        const diffs = await this.getDiffs();
-        const statements = [];
-        for (const diff of diffs){
-            if (diff.type === 'create') {
-                const entity = this.findEntityForTable(diff.tableName);
-                if (entity) {
-                    statements.push(this.schemaGenerator.generateCreateTable(entity));
+            ];
+        } else {
+            relOpts.references = [
+                {
+                    local: `${relKey}Id`,
+                    foreign: relMeta.id
                 }
-            } else if (diff.type === 'alter') {
-                const filteredDiff = this.filterDiff(diff, options);
-                const alterStatements = this.schemaGenerator.generateAlterTable(filteredDiff);
-                statements.push(...alterStatements);
-            }
-        }
-        if (statements.length === 0) {
-            if (options.logging) this.logger('Schema is already in sync.');
-            return;
+            ];
         }
-        await this.executeSyncStatements(statements, options);
-    }
-    filterDiff(diff, options) {
-        const filteredDiff = {
-            ...diff
-        };
-        if (options.safe !== false) {
-            // In safe mode, we only allow additions
-            delete filteredDiff.columnsToDrop;
-            delete filteredDiff.indexesToDrop;
-            delete filteredDiff.foreignKeysToDrop;
-        }
-        if (!options.drop) {
-            delete filteredDiff.columnsToDrop;
-        }
-        return filteredDiff;
-    }
-    async executeSyncStatements(statements, options) {
-        const querier = await this.pool.getQuerier();
-        try {
-            if (this.dialect === 'mongodb') {
-                await this.executeMongoSyncStatements(statements, options, querier);
-            } else {
-                await this.executeSqlSyncStatements(statements, options, querier);
-            }
-            if (options.logging) this.logger('Schema synchronization completed');
-        } catch (error) {
-            if (this.dialect !== 'mongodb' && isSqlQuerier(querier)) {
-                await querier.rollbackTransaction();
-            }
-            throw error;
-        } finally{
-            await querier.release();
+        if (relOpts.through) {
+            fillThroughRelations(relOpts.through());
         }
     }
-    async executeMongoSyncStatements(statements, options, querier) {
-        const db = querier.db;
-        for (const stmt of statements){
-            const cmd = JSON.parse(stmt);
-            if (options.logging) this.logger(`Executing MongoDB: ${stmt}`);
-            const collectionName = cmd.name || cmd.collection;
-            if (!collectionName) {
-                throw new Error(`MongoDB command missing collection name: ${stmt}`);
+    return meta;
+}
+function fillInverseSideRelations(relOpts) {
+    const relEntity = relOpts.entity();
+    const relMeta = getMeta(relEntity);
+    relOpts.mappedBy = getMappedByRelationKey(relOpts);
+    if (relMeta.fields[relOpts.mappedBy]) {
+        relOpts.references = [
+            {
+                local: relMeta.id,
+                foreign: relOpts.mappedBy
             }
-            const collection = db.collection(collectionName);
-            if (cmd.action === 'createCollection') {
-                await db.createCollection(cmd.name);
-                if (cmd.indexes?.length) {
-                    for (const idx of cmd.indexes){
-                        const key = Object.fromEntries(idx.columns.map((c)=>[
-                                c,
-                                1
-                            ]));
-                        await collection.createIndex(key, {
-                            unique: idx.unique,
-                            name: idx.name
-                        });
+        ];
+        return;
+    }
+    const mappedByRelation = relMeta.relations[relOpts.mappedBy];
+    if (relOpts.cardinality === 'm1' || relOpts.cardinality === 'mm') {
+        relOpts.references = mappedByRelation.references.slice().reverse();
+        relOpts.through = mappedByRelation.through;
+        return;
+    }
+    relOpts.references = mappedByRelation.references.map(({ local, foreign })=>({
+            local: foreign,
+            foreign: local
+        }));
+}
+function fillThroughRelations(entity) {
+    const meta = ensureMeta(entity);
+    meta.relations = getKeys(meta.fields).reduce((relations, key)=>{
+        const { reference } = meta.fields[key];
+        if (reference) {
+            const relEntity = reference();
+            const relMeta = ensureMeta(relEntity);
+            const relKey = key.slice(0, -relMeta.id.length);
+            const relOpts = {
+                entity: reference,
+                cardinality: 'm1',
+                references: [
+                    {
+                        local: key,
+                        foreign: relMeta.id
                     }
-                }
-            } else if (cmd.action === 'dropCollection') {
-                await collection.drop();
-            } else if (cmd.action === 'createIndex') {
-                await collection.createIndex(cmd.key, cmd.options);
-            } else if (cmd.action === 'dropIndex') {
-                await collection.dropIndex(cmd.name);
-            }
-        }
-    }
-    async executeSqlSyncStatements(statements, options, querier) {
-        if (!isSqlQuerier(querier)) {
-            throw new Error('Migrator requires a SQL-based querier for this dialect');
-        }
-        await querier.beginTransaction();
-        for (const sql of statements){
-            if (options.logging) this.logger(`Executing: ${sql}`);
-            await querier.run(sql);
-        }
-        await querier.commitTransaction();
-    }
-    /**
-   * Get migration status
-   */ async status() {
-        const [pending, executed] = await Promise.all([
-            this.pending().then((m)=>m.map((x)=>x.name)),
-            this.executed()
-        ]);
-        return {
-            pending,
-            executed
-        };
-    }
-    /**
-   * Get migration files from the migrations directory
-   */ async getMigrationFiles() {
-        try {
-            const files = await readdir(this.migrationsPath);
-            return files.filter((f)=>/\.(ts|js|mjs)$/.test(f)).filter((f)=>!f.endsWith('.d.ts')).sort();
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                return [];
-            }
-            throw error;
-        }
-    }
-    /**
-   * Load a migration from a file
-   */ async loadMigration(fileName) {
-        const filePath = join(this.migrationsPath, fileName);
-        const fileUrl = pathToFileURL(filePath).href;
-        try {
-            const module = await import(fileUrl);
-            const migration = module.default ?? module;
-            if (this.isMigration(migration)) {
-                return {
-                    name: this.getMigrationName(fileName),
-                    up: migration.up.bind(migration),
-                    down: migration.down.bind(migration)
-                };
-            }
-            this.logger(`Warning: ${fileName} is not a valid migration`);
-            return undefined;
-        } catch (error) {
-            this.logger(`Error loading migration ${fileName}: ${error.message}`);
-            return undefined;
+                ]
+            };
+            relations[relKey] = relOpts;
         }
-    }
-    /**
-   * Check if an object is a valid migration
-   */ isMigration(obj) {
-        return typeof obj === 'object' && obj !== undefined && obj !== null && typeof obj.up === 'function' && typeof obj.down === 'function';
-    }
-    /**
-   * Extract migration name from filename
-   */ getMigrationName(fileName) {
-        return basename(fileName, extname(fileName));
-    }
-    /**
-   * Generate timestamp string for migration names
-   */ getTimestamp() {
-        const now = new Date();
-        return [
-            now.getFullYear(),
-            String(now.getMonth() + 1).padStart(2, '0'),
-            String(now.getDate()).padStart(2, '0'),
-            String(now.getHours()).padStart(2, '0'),
-            String(now.getMinutes()).padStart(2, '0'),
-            String(now.getSeconds()).padStart(2, '0')
-        ].join('');
-    }
-    /**
-   * Convert a string to a slug for filenames
-   */ slugify(text) {
-        return text.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
-    }
-    /**
-   * Generate migration file content
-   */ generateMigrationContent(name) {
-        return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';
-
-/**
- * Migration: ${name}
- * Created: ${new Date().toISOString()}
- */
-export default {
-  async up(querier: SqlQuerier): Promise<void> {
-    // Add your migration logic here
-    // Example:
-    // await querier.run(\`
-    //   CREATE TABLE "users" (
-    //     "id" SERIAL PRIMARY KEY,
-    //     "name" VARCHAR(255) NOT NULL,
-    //     "email" VARCHAR(255) UNIQUE NOT NULL,
-    //     "createdAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    //   )
-    // \`);
-  },
-
-  async down(querier: SqlQuerier): Promise<void> {
-    // Add your rollback logic here
-    // Example:
-    // await querier.run(\`DROP TABLE IF EXISTS "users"\`);
-  },
-};
-`;
-    }
-    /**
-   * Generate migration file content with SQL statements
-   */ generateMigrationContentWithStatements(name, upStatements, downStatements) {
-        const upSql = upStatements.map((s)=>/*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
-        const downSql = downStatements.map((s)=>/*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
-        return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';
-
-/**
- * Migration: ${name}
- * Created: ${new Date().toISOString()}
- * Generated from entity definitions
- */
-export default {
-  async up(querier: SqlQuerier): Promise<void> {
-${upSql}
-  },
-
-  async down(querier: SqlQuerier): Promise<void> {
-${downSql}
-  },
-};
-`;
-    }
+        return relations;
+    }, {});
 }
-/**
- * Helper function to define a migration with proper typing
- */ function defineMigration(migration) {
-    return migration;
+function getMappedByRelationKey(relOpts) {
+    if (typeof relOpts.mappedBy === 'function') {
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        const keyMap = getRelationKeyMap(relMeta);
+        return relOpts.mappedBy(keyMap);
+    }
+    return relOpts.mappedBy;
+}
+function getRelationKeyMap(meta) {
+    return getKeys(meta.fields).concat(getKeys(meta.relations)).reduce((acc, key)=>{
+        acc[key] = key;
+        return acc;
+    }, {});
 }
 
-/**
- * Stores migration state in a JSON file (useful for development/testing)
- */ class JsonMigrationStorage {
-    constructor(filePath = './migrations/.uql-migrations.json'){
-        this.cache = null;
-        this.filePath = filePath;
-    }
-    async ensureStorage() {
-        try {
-            await this.load();
-        } catch  {
-            // File doesn't exist, create it
-            await this.save([]);
-        }
-    }
-    async executed() {
-        await this.ensureStorage();
-        return this.cache ?? [];
-    }
-    async logWithQuerier(_querier, migrationName) {
-        const executed = await this.executed();
-        if (!executed.includes(migrationName)) {
-            executed.push(migrationName);
-            executed.sort();
-            await this.save(executed);
+async function createTables(querier, primaryKeyType) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const sql = getDdlForTable(entity, querier, primaryKeyType);
+        return querier.run(sql);
+    }));
+}
+async function dropTables(querier) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const meta = getMeta(entity);
+        const sql = `DROP TABLE IF EXISTS ${querier.dialect.escapeId(meta.name)}`;
+        return querier.run(sql);
+    }));
+}
+async function clearTables(querier) {
+    const entities = getEntities();
+    await Promise.all(entities.map((entity)=>{
+        const ctx = querier.dialect.createContext();
+        querier.dialect.delete(ctx, entity, {});
+        return querier.run(ctx.sql, ctx.values);
+    }));
+}
+function getDdlForTable(entity, querier, primaryKeyType) {
+    const meta = getMeta(entity);
+    let sql = `CREATE TABLE ${querier.dialect.escapeId(meta.name)} (\n\t`;
+    const insertableIdType = 'VARCHAR(36)';
+    const defaultType = 'VARCHAR(255)';
+    const columns = getKeys(meta.fields).map((key)=>{
+        const field = meta.fields[key];
+        let propSql = querier.dialect.escapeId(field.name) + ' ';
+        if (field.isId) {
+            propSql += field.onInsert ? `${insertableIdType} PRIMARY KEY` : primaryKeyType;
+        } else {
+            if (field.type === Number) {
+                propSql += 'BIGINT';
+            } else if (field.type === Date) {
+                propSql += 'TIMESTAMP';
+            } else {
+                propSql += defaultType;
+            }
         }
-    }
-    async unlogWithQuerier(_querier, migrationName) {
-        const executed = await this.executed();
-        const index = executed.indexOf(migrationName);
-        if (index !== -1) {
-            executed.splice(index, 1);
-            await this.save(executed);
+        return propSql;
+    });
+    sql += columns.join(',\n\t');
+    sql += `\n);`;
+    // log('sql', sql);
+    return sql;
+}
+
+function createSpec(spec) {
+    const proto = Object.getPrototypeOf(spec);
+    let describeFn;
+    const specName = proto.constructor.name;
+    if (specName.startsWith('fff')) {
+        describeFn = describe.only;
+    } else if (specName.startsWith('xxx')) {
+        describeFn = describe.skip;
+    } else {
+        describeFn = describe;
+    }
+    describeFn(specName, ()=>createTestCases(spec));
+}
+function createTestCases(spec) {
+    let proto = Object.getPrototypeOf(spec);
+    const processedMethodsMap = {};
+    while(proto.constructor !== Object){
+        for (const key of Object.getOwnPropertyNames(proto)){
+            const isProcessed = processedMethodsMap[key];
+            processedMethodsMap[key] = true;
+            if (isProcessed || key === 'constructor' || typeof spec[key] !== 'function') {
+                continue;
+            }
+            const callback = spec[key].bind(spec);
+            if (hooks[key]) {
+                hooks[key](callback);
+            } else if (key.startsWith('should')) {
+                it(key, callback);
+            } else if (key.startsWith('fffShould')) {
+                it.only(key, callback);
+            } else if (key.startsWith('xxxShould')) {
+                it.skip(key, callback);
+            }
         }
-    }
-    async load() {
-        const content = await readFile(this.filePath, 'utf-8');
-        this.cache = JSON.parse(content);
-    }
-    async save(migrations) {
-        await mkdir(dirname(this.filePath), {
-            recursive: true
-        });
-        await writeFile(this.filePath, JSON.stringify(migrations, null, 2), 'utf-8');
-        this.cache = migrations;
+        proto = Object.getPrototypeOf(proto);
     }
 }
+const hooks = {
+    beforeAll,
+    beforeEach,
+    afterEach,
+    afterAll
+};
 
-export { AbstractSchemaGenerator, DatabaseMigrationStorage, JsonMigrationStorage, MysqlSchemaGenerator as MariadbSchemaGenerator, MariadbSchemaIntrospector, Migrator, MysqlSchemaGenerator, MysqlSchemaIntrospector, PostgresSchemaGenerator, PostgresSchemaIntrospector, SqliteSchemaGenerator, SqliteSchemaIntrospector, defineMigration };
+export { BaseEntity, _Company as Company, _InventoryAdjustment as InventoryAdjustment, _Item as Item, _ItemAdjustment as ItemAdjustment, _ItemTag as ItemTag, _LedgerAccount as LedgerAccount, _MeasureUnit as MeasureUnit, _MeasureUnitCategory as MeasureUnitCategory, _Profile as Profile, _Storehouse as Storehouse, _Tag as Tag, _Tax as Tax, _TaxCategory as TaxCategory, _User as User, _UserWithNonUpdatableId as UserWithNonUpdatableId, clearTables, createSpec, createTables, dropTables };
 //# sourceMappingURL=uql-browser.min.js.map