lakutata/orm.cjs

An IoC-based universal application framework.

"use strict";

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

require("./vendor/Package.4.cjs");

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

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

const r = require("./vendor/Package.12.cjs");

require("./vendor/Package.13.cjs");

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

require("./vendor/Package.62.cjs");

require("./vendor/Package.132.cjs");

require("./vendor/Package.14.cjs");

require("buffer");

require("module");

require("tty");

require("./vendor/Package.10.cjs");

require("util");

require("./vendor/Package.7.cjs");

require("./vendor/Package.8.cjs");

require("os");

require("path");

require("stream");

require("events");

require("fs");

require("./vendor/Package.15.cjs");

require("crypto");

require("fs/promises");

require("./vendor/Package.11.cjs");

require("url");

require("./vendor/Package.63.cjs");

require("node:url");

require("node:path");

require("node:fs");

require("node:fs/promises");

require("node:events");

require("node:stream");

require("node:string_decoder");

var o = t.requireGlobals();

const n = e.getDefaultExportFromCjs(o);

var s = {};

"use strict";

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

var i = {};

"use strict";

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

var u = {};

"use strict";

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

var a = {};

"use strict";

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

var c = {};

"use strict";

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

var d = {};

"use strict";

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

var l = {};

"use strict";

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

var p = {};

"use strict";

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

var y = {};

"use strict";

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

var O = {};

"use strict";

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

var f = {};

"use strict";

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

var b = {};

"use strict";

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

var g = {};

"use strict";

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

var v = {};

"use strict";

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

var _ = v.And = j;

const m = t.FindOperator;

function j(...e) {
    return new m.FindOperator("and", e, true, true);
}

var P = {};

"use strict";

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

var h = P.Any = x;

const M = t.FindOperator;

function x(e) {
    return new M.FindOperator("any", e);
}

var E = {};

"use strict";

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

var R = E.ArrayContainedBy = S;

const B = t.FindOperator;

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

var F = {};

"use strict";

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

var I = F.ArrayContains = T;

const q = t.FindOperator;

function T(e) {
    return new q.FindOperator("arrayContains", e);
}

var C = {};

"use strict";

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

var N = C.ArrayOverlap = D;

const k = t.FindOperator;

function D(e) {
    return new k.FindOperator("arrayOverlap", e);
}

var w = {};

"use strict";

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

var L = w.Between = Q;

const A = t.FindOperator;

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

var U = {};

var K = {};

"use strict";

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

exports.EqualOperator = K.EqualOperator = void 0;

const X = t.FindOperator;

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

exports.EqualOperator = K.EqualOperator = EqualOperator;

"use strict";

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

var z = U.Equal = G;

const Z = K;

function G(e) {
    return new Z.EqualOperator(e);
}

var J = {};

"use strict";

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

var H = J.IsNull = W;

const V = t.FindOperator;

function W() {
    return new V.FindOperator("isNull", undefined, false);
}

var Y = {};

"use strict";

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

var $ = Y.LessThan = te;

const ee = t.FindOperator;

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

var re = {};

"use strict";

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

var oe = re.LessThanOrEqual = se;

const ne = t.FindOperator;

function se(e) {
    return new ne.FindOperator("lessThanOrEqual", e);
}

var ie = {};

"use strict";

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

var ue = ie.ILike = ce;

const ae = t.FindOperator;

function ce(e) {
    return new ae.FindOperator("ilike", e);
}

var de = {};

"use strict";

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

var le = de.Like = ye;

const pe = t.FindOperator;

function ye(e) {
    return new pe.FindOperator("like", e);
}

var Oe = {};

"use strict";

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

var fe = Oe.MoreThan = ge;

const be = t.FindOperator;

function ge(e) {
    return new be.FindOperator("moreThan", e);
}

var ve = {};

"use strict";

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

var _e = ve.MoreThanOrEqual = je;

const me = t.FindOperator;

function je(e) {
    return new me.FindOperator("moreThanOrEqual", e);
}

var Pe = {};

"use strict";

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

var he = Pe.Not = xe;

const Me = t.FindOperator;

function xe(e) {
    return new Me.FindOperator("not", e);
}

var Ee = {};

"use strict";

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

var Re = Ee.Raw = Se;

const Be = t.FindOperator;

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

var Fe = {};

"use strict";

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

var Ie = Fe.JsonContains = Te;

const qe = t.FindOperator;

function Te(e) {
    return new qe.FindOperator("jsonContains", e);
}

var Ce = {};

"use strict";

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

var Ne = {};

"use strict";

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

var ke = {};

"use strict";

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

var De = {};

"use strict";

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

var we = {};

"use strict";

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

var Le = {};

"use strict";

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

var Ae = {};

"use strict";

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

var Qe = {};

"use strict";

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

var Ue = {};

"use strict";

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

var Ke = {};

"use strict";

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

var Xe = {};

"use strict";

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

var ze = {};

"use strict";

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

var Ze = t.requireEntityManager();

const Ge = e.getDefaultExportFromCjs(Ze);

var Je = t.requireAbstractRepository();

const He = e.getDefaultExportFromCjs(Je);

var Ve = {};

"use strict";

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

exports.BaseEntity = Ve.BaseEntity = void 0;

const We = t.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);
        We.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 = Ve.BaseEntity = BaseEntity;

var Ye = {};

"use strict";

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

var $e = {};

"use strict";

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

var et = {};

"use strict";

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

var tt = {};

"use strict";

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

var rt = {};

"use strict";

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

var ot = {};

"use strict";

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

var nt = {};

"use strict";

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

var st = {};

"use strict";

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

var it = {};

"use strict";

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

var ut = {};

"use strict";

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

var at = {};

var ct = {};

"use strict";

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

var dt = ct.BSON = void 0;

(function(e) {
    "use strict";
    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 = ct;
    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;
        }
    });
})(at);

const lt = e.getDefaultExportFromCjs(at);

var pt = {};

"use strict";

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

var yt = {};

"use strict";

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

var Ot = {};

"use strict";

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

var ft = {};

"use strict";

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

exports.NotBrackets = ft.NotBrackets = void 0;

const bt = t.Brackets;

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

exports.NotBrackets = ft.NotBrackets = NotBrackets;

var gt = t.requireMongoEntityManager();

const vt = e.getDefaultExportFromCjs(gt);

var _t = {};

"use strict";

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

exports.LegacyOracleNamingStrategy = _t.LegacyOracleNamingStrategy = void 0;

const mt = t.RandomGenerator;

const jt = t.DefaultNamingStrategy;

const Pt = t.error;

class LegacyOracleNamingStrategy extends jt.DefaultNamingStrategy {
    constructor(e = "hash") {
        super();
        this.IDENTIFIER_MAX_SIZE = 30;
        this.DEFAULT_COLUMN_PREFIX = "COL_";
        this.shortenStrategy = e;
    }
    columnName(e, t, r) {
        const o = super.columnName(e, t, r);
        if (this.shortenStrategy === "truncate") {
            return this.truncateIdentifier(o);
        } else if (this.shortenStrategy === "hash") {
            return this.hashIdentifier(o, this.DEFAULT_COLUMN_PREFIX);
        } else {
            throw new Pt.TypeORMError(`Invalid shortenStrategy`);
        }
    }
    hashIdentifier(e, t) {
        if (t.length >= this.IDENTIFIER_MAX_SIZE) {
            throw new Pt.TypeORMError(`Prefix must be shorter than IDENTIFIER_MAX_SIZE`);
        }
        return t + mt.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 = _t.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;

var ht = {};

"use strict";

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

exports.EntitySchema = ht.EntitySchema = void 0;

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

exports.EntitySchema = ht.EntitySchema = EntitySchema;

var Mt = {};

"use strict";

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

exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = void 0;

class EntitySchemaEmbeddedColumnOptions {}

exports.EntitySchemaEmbeddedColumnOptions = Mt.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;

var xt = {};

"use strict";

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

exports.EntitySchemaOptions = xt.EntitySchemaOptions = void 0;

class EntitySchemaOptions {}

exports.EntitySchemaOptions = xt.EntitySchemaOptions = EntitySchemaOptions;

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

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

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

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

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

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

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

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

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

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

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

exports.In = t.In_2;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

exports.getFromContainer = t.getFromContainer_1;

exports.useContainer = t.useContainer_1;

exports.And = _;

exports.Any = h;

exports.ArrayContainedBy = R;

exports.ArrayContains = I;

exports.ArrayOverlap = N;

exports.Between = L;

exports.DataSource = r.DataSourceExports.DataSource;

exports.Equal = z;

exports.ILike = ue;

exports.IsNull = H;

exports.JsonContains = Ie;

exports.LessThan = $;

exports.LessThanOrEqual = oe;

exports.Like = le;

exports.MongoEntityManager = gt.MongoEntityManager;

exports.MoreThan = fe;

exports.MoreThanOrEqual = _e;

exports.Not = he;

exports.Raw = Re;