@uql/core 3.4.4 → 3.4.5

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

@@ -1,1018 +1,865 @@
-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';
+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';
 
-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
-});
 /**
- * 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);
+ * Abstract base class for SQL schema generation
+ */ class AbstractSchemaGenerator extends AbstractDialect {
+    constructor(namingStrategy, escapeIdChar = '`'){
+        super(namingStrategy), this.escapeIdChar = escapeIdChar;
     }
-}
-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();
+    /**
+   * Escape an identifier (table name, column name, etc.)
+   */ escapeId(identifier) {
+        return escapeSqlId(identifier, this.escapeIdChar);
     }
-    constructor(...args){
-        super(...args), this.name = _init_name(this), this.description = _init_description(this), this.kind = _init_kind(this);
+    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;
     }
-}
-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();
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
     }
-    constructor(...args){
-        super(...args), this.pk = _init_pk(this), this.picture = _init_picture(this);
+    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;
     }
-}
-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();
+    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;
     }
-    constructor(...args){
-        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);
+    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});`;
     }
-}
-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);
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
     }
-}
-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();
+    /**
+   * 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;
     }
-    constructor(...args){
-        super(...args), this.name = _init_name3(this), this.description = _init_description1(this), this.parentLedgerId = _init_parentLedgerId(this), this.parentLedger = _init_parentLedger(this);
+    /**
+   * 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;
     }
-}
-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();
+    /**
+   * 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;
     }
-    constructor(...args){
-        super(...args), this.pk = _init_pk1(this), this.name = _init_name4(this), this.description = _init_description2(this);
+    /**
+   * 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;
     }
-}
-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();
+    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})`;
     }
-    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);
+    /**
+   * Get table options (e.g., ENGINE for MySQL)
+   */ getTableOptions(meta) {
+        return '';
     }
-}
-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();
+    /**
+   * 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);
     }
-    constructor(...args){
-        super(...args), this.name = _init_name6(this), this.measureUnits = _init_measureUnits(this), this.deletedAt = _init_deletedAt(this);
+    /**
+   * 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
+        };
     }
-}
-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();
+    /**
+   * 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
+        };
     }
-    constructor(...args){
-        super(...args), this.name = _init_name7(this), this.categoryId = _init_categoryId1(this), this.category = _init_category1(this), this.deletedAt = _init_deletedAt1(this);
+    /**
+   * 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);
     }
 }
-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();
+
+/**
+ * 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)};`;
     }
     constructor(...args){
-        super(...args), this.name = _init_name8(this), this.address = _init_address(this), this.description = _init_description4(this);
+        super(...args), this.serialPrimaryKeyType = 'INT AUTO_INCREMENT PRIMARY KEY';
     }
 }
-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({
+
+/**
+ * PostgreSQL-specific schema generator
+ */ class PostgresSchemaGenerator extends AbstractSchemaGenerator {
+    constructor(namingStrategy){
+        super(namingStrategy, '"'), this.serialPrimaryKeyType = 'SERIAL PRIMARY KEY';
+    }
+    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 '';
+    }
     /**
-     * `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();
+   * 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}';`;
     }
-    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) {
+        // PostgreSQL doesn't require table name in DROP INDEX
+        return `DROP INDEX IF EXISTS ${this.escapeId(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();
+
+/**
+ * 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';
+        }
     }
-    constructor(...args){
-        super(...args), this.name = _init_name10(this), this.items = _init_items(this), this.itemsCount = _init_itemsCount(this);
+    getBooleanType() {
+        return 'INTEGER';
     }
-}
-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);
+    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.');
     }
-}
-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();
+    generateColumnComment(tableName, columnName, comment) {
+        return '';
     }
-    constructor(...args){
-        super(...args), this.itemAdjustments = _init_itemAdjustments(this), this.date = _init_date(this), this.description = _init_description6(this);
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
     }
-}
-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();
+    formatDefaultValue(value) {
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        return super.formatDefaultValue(value);
     }
     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);
+        super(...args), this.serialPrimaryKeyType = 'INTEGER PRIMARY KEY AUTOINCREMENT';
     }
 }
 
-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`);
+/**
+ * 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();
+        }
     }
-    if (meta.processed) {
-        return meta;
+    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();
+        }
     }
-    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 {
-            relOpts.references = [
-                {
-                    local: `${relKey}Id`,
-                    foreign: relMeta.id
-                }
-            ];
+    async tableExists(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            return this.tableExistsInternal(querier, tableName);
+        } finally{
+            await querier.release();
         }
-        if (relOpts.through) {
-            fillThroughRelations(relOpts.through());
+    }
+    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;
     }
-    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
-            }
-        ];
-        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
-                    }
-                ]
-            };
-            relations[relKey] = relOpts;
+    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 relations;
-    }, {});
-}
-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;
-    }, {});
-}
-
-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;
-            }
+        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;
         }
-        return propSql;
-    });
-    sql += columns.join(',\n\t');
-    sql += `\n);`;
-    // log('sql', sql);
-    return sql;
+    }
 }
+/**
+ * Alias for MysqlSchemaIntrospector.
+ * MariaDB uses the same information_schema structure as MySQL.
+ */ const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
 
-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);
+/**
+ * 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();
         }
-        proto = Object.getPrototypeOf(proto);
     }
-}
-const hooks = {
-    beforeAll,
-    beforeEach,
-    afterEach,
-    afterAll
-};
-
-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
-nst querier = await this.getQuerier();
+    async getTableNames() {
+        const querier = await this.getQuerier();
         try {
             const sql = `
         SELECT table_name