lakutata/orm.cjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

require("./vendor/Package.internal.1.cjs");

const e = require("./vendor/Package.internal.51.cjs");

const t = require("./vendor/Package.internal.512.cjs");

require("./vendor/Package.internal.2.cjs");

require("./vendor/Package.internal.310.cjs");

require("./vendor/Package.internal.3.cjs");

require("./vendor/Package.internal.52.cjs");

require("buffer");

require("tty");

require("util");

require("./vendor/Package.internal.6.cjs");

require("fs");

require("path");

require("os");

require("crypto");

require("events");

require("stream");

require("module");

require("fs/promises");

require("url");

require("node:url");

require("node:path");

require("node:fs");

require("node:fs/promises");

require("node:events");

require("node:stream");

require("node:string_decoder");

e.requireGlobals();

var r = {};

Object.defineProperty(r, "__esModule", {
    value: true
});

var n = {};

Object.defineProperty(n, "__esModule", {
    value: true
});

var o = {};

Object.defineProperty(o, "__esModule", {
    value: true
});

var i = {};

Object.defineProperty(i, "__esModule", {
    value: true
});

var u = {};

Object.defineProperty(u, "__esModule", {
    value: true
});

var a = {};

Object.defineProperty(a, "__esModule", {
    value: true
});

var s = {};

Object.defineProperty(s, "__esModule", {
    value: true
});

var d = {};

Object.defineProperty(d, "__esModule", {
    value: true
});

var c = {};

Object.defineProperty(c, "__esModule", {
    value: true
});

var l = {};

Object.defineProperty(l, "__esModule", {
    value: true
});

var p = {};

Object.defineProperty(p, "__esModule", {
    value: true
});

var y = {};

Object.defineProperty(y, "__esModule", {
    value: true
});

var O = {};

Object.defineProperty(O, "__esModule", {
    value: true
});

var b = {};

Object.defineProperty(b, "__esModule", {
    value: true
});

exports.And = b.And = g;

const f = e.FindOperator;

function g(...e) {
    return new f.FindOperator("and", e, true, true);
}

var _ = {};

Object.defineProperty(_, "__esModule", {
    value: true
});

exports.Or = _.Or = m;

const v = e.FindOperator;

function m(...e) {
    return new v.FindOperator("or", e, true, true);
}

var j = {};

Object.defineProperty(j, "__esModule", {
    value: true
});

exports.Any = j.Any = h;

const P = e.FindOperator;

function h(e) {
    return new P.FindOperator("any", e);
}

var M = {};

Object.defineProperty(M, "__esModule", {
    value: true
});

exports.ArrayContainedBy = M.ArrayContainedBy = E;

const x = e.FindOperator;

function E(e) {
    return new x.FindOperator("arrayContainedBy", e);
}

var R = {};

Object.defineProperty(R, "__esModule", {
    value: true
});

exports.ArrayContains = R.ArrayContains = S;

const B = e.FindOperator;

function S(e) {
    return new B.FindOperator("arrayContains", e);
}

var F = {};

Object.defineProperty(F, "__esModule", {
    value: true
});

exports.ArrayOverlap = F.ArrayOverlap = q;

const I = e.FindOperator;

function q(e) {
    return new I.FindOperator("arrayOverlap", e);
}

var T = {};

Object.defineProperty(T, "__esModule", {
    value: true
});

exports.Between = T.Between = C;

const N = e.FindOperator;

function C(e, t) {
    return new N.FindOperator("between", [ e, t ], true, true);
}

var w = {};

var D = {};

Object.defineProperty(D, "__esModule", {
    value: true
});

exports.EqualOperator = D.EqualOperator = void 0;

const L = e.FindOperator;

class EqualOperator extends L.FindOperator {
    constructor(e) {
        super("equal", e);
        this["@instanceof"] = Symbol.for("EqualOperator");
    }
}

exports.EqualOperator = D.EqualOperator = EqualOperator;

Object.defineProperty(w, "__esModule", {
    value: true
});

exports.Equal = w.Equal = A;

const k = D;

function A(e) {
    return new k.EqualOperator(e);
}

var Q = {};

Object.defineProperty(Q, "__esModule", {
    value: true
});

exports.IsNull = Q.IsNull = K;

const U = e.FindOperator;

function K() {
    return new U.FindOperator("isNull", undefined, false);
}

var X = {};

Object.defineProperty(X, "__esModule", {
    value: true
});

exports.LessThan = X.LessThan = Z;

const z = e.FindOperator;

function Z(e) {
    return new z.FindOperator("lessThan", e);
}

var G = {};

Object.defineProperty(G, "__esModule", {
    value: true
});

exports.LessThanOrEqual = G.LessThanOrEqual = H;

const J = e.FindOperator;

function H(e) {
    return new J.FindOperator("lessThanOrEqual", e);
}

var V = {};

Object.defineProperty(V, "__esModule", {
    value: true
});

exports.ILike = V.ILike = Y;

const W = e.FindOperator;

function Y(e) {
    return new W.FindOperator("ilike", e);
}

var $ = {};

Object.defineProperty($, "__esModule", {
    value: true
});

exports.Like = $.Like = te;

const ee = e.FindOperator;

function te(e) {
    return new ee.FindOperator("like", e);
}

var re = {};

Object.defineProperty(re, "__esModule", {
    value: true
});

exports.MoreThan = re.MoreThan = oe;

const ne = e.FindOperator;

function oe(e) {
    return new ne.FindOperator("moreThan", e);
}

var ie = {};

Object.defineProperty(ie, "__esModule", {
    value: true
});

exports.MoreThanOrEqual = ie.MoreThanOrEqual = ae;

const ue = e.FindOperator;

function ae(e) {
    return new ue.FindOperator("moreThanOrEqual", e);
}

var se = {};

Object.defineProperty(se, "__esModule", {
    value: true
});

exports.Not = se.Not = ce;

const de = e.FindOperator;

function ce(e) {
    return new de.FindOperator("not", e);
}

var le = {};

Object.defineProperty(le, "__esModule", {
    value: true
});

exports.Raw = le.Raw = ye;

const pe = e.FindOperator;

function ye(e, t) {
    if (typeof e !== "function") {
        return new pe.FindOperator("raw", e, false);
    }
    return new pe.FindOperator("raw", [], true, true, e, t);
}

var Oe = {};

Object.defineProperty(Oe, "__esModule", {
    value: true
});

exports.JsonContains = Oe.JsonContains = fe;

const be = e.FindOperator;

function fe(e) {
    return new be.FindOperator("jsonContains", e);
}

var ge = {};

Object.defineProperty(ge, "__esModule", {
    value: true
});

var _e = {};

Object.defineProperty(_e, "__esModule", {
    value: true
});

var ve = {};

Object.defineProperty(ve, "__esModule", {
    value: true
});

var me = {};

Object.defineProperty(me, "__esModule", {
    value: true
});

var je = {};

Object.defineProperty(je, "__esModule", {
    value: true
});

var Pe = {};

Object.defineProperty(Pe, "__esModule", {
    value: true
});

var he = {};

Object.defineProperty(he, "__esModule", {
    value: true
});

var Me = {};

Object.defineProperty(Me, "__esModule", {
    value: true
});

var xe = {};

Object.defineProperty(xe, "__esModule", {
    value: true
});

var Ee = {};

Object.defineProperty(Ee, "__esModule", {
    value: true
});

var Re = {};

Object.defineProperty(Re, "__esModule", {
    value: true
});

var Be = {};

Object.defineProperty(Be, "__esModule", {
    value: true
});

e.requireEntityManager();

e.requireAbstractRepository();

var Se = {};

Object.defineProperty(Se, "__esModule", {
    value: true
});

exports.BaseEntity = Se.BaseEntity = void 0;

const Fe = e.ObjectUtils;

class BaseEntity {
    hasId() {
        const e = this.constructor;
        return e.getRepository().hasId(this);
    }
    save(e) {
        const t = this.constructor;
        return t.getRepository().save(this, e);
    }
    remove(e) {
        const t = this.constructor;
        return t.getRepository().remove(this, e);
    }
    softRemove(e) {
        const t = this.constructor;
        return t.getRepository().softRemove(this, e);
    }
    recover(e) {
        const t = this.constructor;
        return t.getRepository().recover(this, e);
    }
    async reload() {
        const e = this.constructor;
        const t = e.getRepository().metadata.getEntityIdMap(this);
        if (!t) {
            throw new Error(`Entity doesn't have id-s set, cannot reload entity`);
        }
        const r = await e.getRepository().findOneByOrFail(t);
        Fe.ObjectUtils.assign(this, r);
    }
    static useDataSource(e) {
        this.dataSource = e;
    }
    static getRepository() {
        const e = this.dataSource;
        if (!e) throw new Error(`DataSource is not set for this entity.`);
        return e.getRepository(this);
    }
    static get target() {
        return this.getRepository().target;
    }
    static hasId(e) {
        return this.getRepository().hasId(e);
    }
    static getId(e) {
        return this.getRepository().getId(e);
    }
    static createQueryBuilder(e) {
        return this.getRepository().createQueryBuilder(e);
    }
    static create(e) {
        return this.getRepository().create(e);
    }
    static merge(e, ...t) {
        return this.getRepository().merge(e, ...t);
    }
    static preload(e) {
        const t = this.getRepository();
        return t.preload(e);
    }
    static save(e, t) {
        return this.getRepository().save(e, t);
    }
    static remove(e, t) {
        return this.getRepository().remove(e, t);
    }
    static softRemove(e, t) {
        return this.getRepository().softRemove(e, t);
    }
    static insert(e) {
        return this.getRepository().insert(e);
    }
    static update(e, t) {
        return this.getRepository().update(e, t);
    }
    static upsert(e, t) {
        return this.getRepository().upsert(e, t);
    }
    static delete(e) {
        return this.getRepository().delete(e);
    }
    static exists(e) {
        return this.getRepository().exists(e);
    }
    static existsBy(e) {
        return this.getRepository().existsBy(e);
    }
    static count(e) {
        return this.getRepository().count(e);
    }
    static countBy(e) {
        return this.getRepository().countBy(e);
    }
    static sum(e, t) {
        return this.getRepository().sum(e, t);
    }
    static average(e, t) {
        return this.getRepository().average(e, t);
    }
    static minimum(e, t) {
        return this.getRepository().minimum(e, t);
    }
    static maximum(e, t) {
        return this.getRepository().maximum(e, t);
    }
    static find(e) {
        return this.getRepository().find(e);
    }
    static findBy(e) {
        return this.getRepository().findBy(e);
    }
    static findAndCount(e) {
        return this.getRepository().findAndCount(e);
    }
    static findAndCountBy(e) {
        return this.getRepository().findAndCountBy(e);
    }
    static findByIds(e) {
        return this.getRepository().findByIds(e);
    }
    static findOne(e) {
        return this.getRepository().findOne(e);
    }
    static findOneBy(e) {
        return this.getRepository().findOneBy(e);
    }
    static findOneById(e) {
        return this.getRepository().findOneById(e);
    }
    static findOneOrFail(e) {
        return this.getRepository().findOneOrFail(e);
    }
    static findOneByOrFail(e) {
        return this.getRepository().findOneByOrFail(e);
    }
    static query(e, t) {
        return this.getRepository().query(e, t);
    }
    static clear() {
        return this.getRepository().clear();
    }
}

exports.BaseEntity = Se.BaseEntity = BaseEntity;

var Ie = {};

Object.defineProperty(Ie, "__esModule", {
    value: true
});

var qe = {};

Object.defineProperty(qe, "__esModule", {
    value: true
});

var Te = {};

Object.defineProperty(Te, "__esModule", {
    value: true
});

var Ne = {};

Object.defineProperty(Ne, "__esModule", {
    value: true
});

var Ce = {};

Object.defineProperty(Ce, "__esModule", {
    value: true
});

var we = {};

Object.defineProperty(we, "__esModule", {
    value: true
});

var De = {};

Object.defineProperty(De, "__esModule", {
    value: true
});

var Le = {};

Object.defineProperty(Le, "__esModule", {
    value: true
});

var ke = {};

Object.defineProperty(ke, "__esModule", {
    value: true
});

var Ae = {};

Object.defineProperty(Ae, "__esModule", {
    value: true
});

var Qe = {};

var Ue = {};

Object.defineProperty(Ue, "__esModule", {
    value: true
});

Ue.BSON = void 0;

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.Timestamp = e.serialize = e.ObjectId = e.MinKey = e.MaxKey = e.Long = e.Int32 = e.Double = e.deserialize = e.Decimal128 = e.DBRef = e.Code = e.BSONType = e.BSONSymbol = e.BSONRegExp = e.BSON = e.Binary = void 0;
    const t = Ue;
    Object.defineProperty(e, "BSON", {
        enumerable: true,
        get: function() {
            return t.BSON;
        }
    });
    Object.defineProperty(e, "BSONRegExp", {
        enumerable: true,
        get: function() {
            return t.BSONRegExp;
        }
    });
    Object.defineProperty(e, "BSONSymbol", {
        enumerable: true,
        get: function() {
            return t.BSONSymbol;
        }
    });
    Object.defineProperty(e, "BSONType", {
        enumerable: true,
        get: function() {
            return t.BSONType;
        }
    });
    Object.defineProperty(e, "Binary", {
        enumerable: true,
        get: function() {
            return t.Binary;
        }
    });
    Object.defineProperty(e, "Code", {
        enumerable: true,
        get: function() {
            return t.Code;
        }
    });
    Object.defineProperty(e, "DBRef", {
        enumerable: true,
        get: function() {
            return t.DBRef;
        }
    });
    Object.defineProperty(e, "Decimal128", {
        enumerable: true,
        get: function() {
            return t.Decimal128;
        }
    });
    Object.defineProperty(e, "Double", {
        enumerable: true,
        get: function() {
            return t.Double;
        }
    });
    Object.defineProperty(e, "Int32", {
        enumerable: true,
        get: function() {
            return t.Int32;
        }
    });
    Object.defineProperty(e, "Long", {
        enumerable: true,
        get: function() {
            return t.Long;
        }
    });
    Object.defineProperty(e, "MaxKey", {
        enumerable: true,
        get: function() {
            return t.MaxKey;
        }
    });
    Object.defineProperty(e, "MinKey", {
        enumerable: true,
        get: function() {
            return t.MinKey;
        }
    });
    Object.defineProperty(e, "ObjectId", {
        enumerable: true,
        get: function() {
            return t.ObjectId;
        }
    });
    Object.defineProperty(e, "Timestamp", {
        enumerable: true,
        get: function() {
            return t.Timestamp;
        }
    });
    Object.defineProperty(e, "deserialize", {
        enumerable: true,
        get: function() {
            return t.deserialize;
        }
    });
    Object.defineProperty(e, "serialize", {
        enumerable: true,
        get: function() {
            return t.serialize;
        }
    });
})(Qe);

var Ke = {};

Object.defineProperty(Ke, "__esModule", {
    value: true
});

var Xe = {};

Object.defineProperty(Xe, "__esModule", {
    value: true
});

var ze = {};

Object.defineProperty(ze, "__esModule", {
    value: true
});

var Ze = {};

Object.defineProperty(Ze, "__esModule", {
    value: true
});

exports.NotBrackets = Ze.NotBrackets = void 0;

const Ge = e.Brackets;

class NotBrackets extends Ge.Brackets {
    constructor() {
        super(...arguments);
        this["@instanceof"] = Symbol.for("NotBrackets");
    }
}

exports.NotBrackets = Ze.NotBrackets = NotBrackets;

var Je = e.requireMongoEntityManager();

var He = {};

Object.defineProperty(He, "__esModule", {
    value: true
});

exports.LegacyOracleNamingStrategy = He.LegacyOracleNamingStrategy = void 0;

const Ve = e.RandomGenerator;

const We = e.DefaultNamingStrategy;

const Ye = e.error;

class LegacyOracleNamingStrategy extends We.DefaultNamingStrategy {
    constructor(e = "hash") {
        super();
        this.IDENTIFIER_MAX_SIZE = 30;
        this.DEFAULT_COLUMN_PREFIX = "COL_";
        this.shortenStrategy = e;
    }
    columnName(e, t, r) {
        const n = super.columnName(e, t, r);
        if (this.shortenStrategy === "truncate") {
            return this.truncateIdentifier(n);
        } else if (this.shortenStrategy === "hash") {
            return this.hashIdentifier(n, this.DEFAULT_COLUMN_PREFIX);
        } else {
            throw new Ye.TypeORMError(`Invalid shortenStrategy`);
        }
    }
    hashIdentifier(e, t) {
        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
            throw new Ye.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
        }
        return t + Ve.RandomGenerator.sha1(e).substring(0, this.IDENTIFIER_MAX_SIZE - t.length);
    }
    truncateIdentifier(e) {
        if (e.length > this.IDENTIFIER_MAX_SIZE) {
            return e.substring(0, this.IDENTIFIER_MAX_SIZE);
        } else {
            return e;
        }
    }
}

exports.LegacyOracleNamingStrategy = He.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;

var $e = {};

Object.defineProperty($e, "__esModule", {
    value: true
});

exports.EntitySchema = $e.EntitySchema = void 0;

class EntitySchema {
    constructor(e) {
        this.options = e;
        this["@instanceof"] = Symbol.for("EntitySchema");
    }
}

exports.EntitySchema = $e.EntitySchema = EntitySchema;

var et = {};

Object.defineProperty(et, "__esModule", {
    value: true
});

exports.EntitySchemaEmbeddedColumnOptions = et.EntitySchemaEmbeddedColumnOptions = void 0;

class EntitySchemaEmbeddedColumnOptions {}

exports.EntitySchemaEmbeddedColumnOptions = et.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;

var tt = {};

Object.defineProperty(tt, "__esModule", {
    value: true
});

exports.EntitySchemaOptions = tt.EntitySchemaOptions = void 0;

class EntitySchemaOptions {}

exports.EntitySchemaOptions = tt.EntitySchemaOptions = EntitySchemaOptions;

Object.defineProperty(exports, "AbstractLogger", {
    enumerable: true,
    get: () => e.AbstractLogger_2
});

Object.defineProperty(exports, "AdvancedConsoleLogger", {
    enumerable: true,
    get: () => e.AdvancedConsoleLogger_2
});

Object.defineProperty(exports, "Brackets", {
    enumerable: true,
    get: () => e.Brackets_2
});

Object.defineProperty(exports, "ConnectionOptionsReader", {
    enumerable: true,
    get: () => e.ConnectionOptionsReader_2
});

Object.defineProperty(exports, "DefaultNamingStrategy", {
    enumerable: true,
    get: () => e.DefaultNamingStrategy_2
});

Object.defineProperty(exports, "DeleteQueryBuilder", {
    enumerable: true,
    get: () => e.DeleteQueryBuilder_2
});

Object.defineProperty(exports, "DeleteResult", {
    enumerable: true,
    get: () => e.DeleteResult_2
});

Object.defineProperty(exports, "EntityMetadata", {
    enumerable: true,
    get: () => e.EntityMetadata_2
});

Object.defineProperty(exports, "FileLogger", {
    enumerable: true,
    get: () => e.FileLogger_2
});

Object.defineProperty(exports, "FindOperator", {
    enumerable: true,
    get: () => e.FindOperator_2
});

Object.defineProperty(exports, "FindOptionsUtils", {
    enumerable: true,
    get: () => e.FindOptionsUtils_2
});

Object.defineProperty(exports, "In", {
    enumerable: true,
    get: () => e.In_2
});

Object.defineProperty(exports, "InsertQueryBuilder", {
    enumerable: true,
    get: () => e.InsertQueryBuilder_2
});

Object.defineProperty(exports, "InsertResult", {
    enumerable: true,
    get: () => e.InsertResult_2
});

Object.defineProperty(exports, "InstanceChecker", {
    enumerable: true,
    get: () => e.InstanceChecker_2
});

Object.defineProperty(exports, "Migration", {
    enumerable: true,
    get: () => e.Migration_2
});

Object.defineProperty(exports, "MigrationExecutor", {
    enumerable: true,
    get: () => e.MigrationExecutor_2
});

Object.defineProperty(exports, "MongoRepository", {
    enumerable: true,
    get: () => e.MongoRepository_2
});

Object.defineProperty(exports, "MssqlParameter", {
    enumerable: true,
    get: () => e.MssqlParameter_2
});

Object.defineProperty(exports, "QueryBuilder", {
    enumerable: true,
    get: () => e.QueryBuilder_2
});

Object.defineProperty(exports, "QueryResult", {
    enumerable: true,
    get: () => e.QueryResult_2
});

Object.defineProperty(exports, "RelationQueryBuilder", {
    enumerable: true,
    get: () => e.RelationQueryBuilder_2
});

Object.defineProperty(exports, "Repository", {
    enumerable: true,
    get: () => e.Repository_2
});

Object.defineProperty(exports, "SelectQueryBuilder", {
    enumerable: true,
    get: () => e.SelectQueryBuilder_2
});

Object.defineProperty(exports, "SimpleConsoleLogger", {
    enumerable: true,
    get: () => e.SimpleConsoleLogger_2
});

Object.defineProperty(exports, "Table", {
    enumerable: true,
    get: () => e.Table_2
});

Object.defineProperty(exports, "TableCheck", {
    enumerable: true,
    get: () => e.TableCheck_2
});

Object.defineProperty(exports, "TableColumn", {
    enumerable: true,
    get: () => e.TableColumn_2
});

Object.defineProperty(exports, "TableExclusion", {
    enumerable: true,
    get: () => e.TableExclusion_2
});

Object.defineProperty(exports, "TableForeignKey", {
    enumerable: true,
    get: () => e.TableForeignKey_2
});

Object.defineProperty(exports, "TableIndex", {
    enumerable: true,
    get: () => e.TableIndex_2
});

Object.defineProperty(exports, "TableUnique", {
    enumerable: true,
    get: () => e.TableUnique_2
});

Object.defineProperty(exports, "TreeRepository", {
    enumerable: true,
    get: () => e.TreeRepository_2
});

Object.defineProperty(exports, "TreeRepositoryUtils", {
    enumerable: true,
    get: () => e.TreeRepositoryUtils_2
});

Object.defineProperty(exports, "UpdateQueryBuilder", {
    enumerable: true,
    get: () => e.UpdateQueryBuilder_2
});

Object.defineProperty(exports, "UpdateResult", {
    enumerable: true,
    get: () => e.UpdateResult_2
});

Object.defineProperty(exports, "getFromContainer", {
    enumerable: true,
    get: () => e.getFromContainer_1
});

Object.defineProperty(exports, "useContainer", {
    enumerable: true,
    get: () => e.useContainer_1
});

exports.DataSource = t.DataSourceExports.DataSource;

exports.MongoEntityManager = Je.MongoEntityManager;