lakutata/orm.mjs

An IoC-based universal application framework.

import "./vendor/Package.4.mjs";

import { g as e } from "./vendor/Package.5.mjs";

import { a as r, F as a, c, d, O as f, B as O, f as _, R as b, D as E, e as R } from "./vendor/Package.122.mjs";

export { A as AbstractLogger, x as AdvancedConsoleLogger, j as Brackets, g as ConnectionOptionsReader, p as DefaultNamingStrategy, h as DeleteQueryBuilder, m as DeleteResult, G as EntityMetadata, z as FileLogger, v as FindOperator, w as FindOptionsUtils, t as In, I as InsertQueryBuilder, k as InsertResult, q as InstanceChecker, M as Migration, o as MigrationExecutor, K as MongoRepository, Z as MssqlParameter, Q as QueryBuilder, n as QueryResult, i as RelationQueryBuilder, H as Repository, S as SelectQueryBuilder, y as SimpleConsoleLogger, Y as Table, L as TableCheck, N as TableColumn, P as TableExclusion, V as TableForeignKey, W as TableIndex, X as TableUnique, J as TreeRepository, T as TreeRepositoryUtils, U as UpdateQueryBuilder, l as UpdateResult, s as getFromContainer, u as useContainer } from "./vendor/Package.122.mjs";

import { D as B } from "./vendor/Package.12.mjs";

import "./vendor/Package.13.mjs";

import "./vendor/Package.1.mjs";

import "./vendor/Package.62.mjs";

import "./vendor/Package.132.mjs";

import "./vendor/Package.14.mjs";

import "buffer";

import "module";

import "tty";

import "./vendor/Package.10.mjs";

import "util";

import "./vendor/Package.7.mjs";

import "./vendor/Package.8.mjs";

import "os";

import "path";

import "stream";

import "events";

import "fs";

import "./vendor/Package.15.mjs";

import "crypto";

import "fs/promises";

import "./vendor/Package.11.mjs";

import "url";

import "./vendor/Package.63.mjs";

import "node:url";

import "node:path";

import "node:fs";

import "node:fs/promises";

import "node:events";

import "node:stream";

import "node:string_decoder";

var F = r();

const C = e(F);

var D = {};

"use strict";

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

var $ = {};

"use strict";

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

var ee = {};

"use strict";

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

var te = {};

"use strict";

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

var re = {};

"use strict";

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

var se = {};

"use strict";

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

var ne = {};

"use strict";

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

var ae = {};

"use strict";

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

var oe = {};

"use strict";

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

var ie = {};

"use strict";

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

var ue = {};

"use strict";

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

var ce = {};

"use strict";

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

var de = {};

"use strict";

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

var le = {};

"use strict";

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

var ye = le.And = ve;

const pe = a;

function ve(...e) {
    return new pe.FindOperator("and", e, true, true);
}

var fe = {};

"use strict";

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

var Oe = fe.Any = _e;

const me = a;

function _e(e) {
    return new me.FindOperator("any", e);
}

var ge = {};

"use strict";

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

var be = ge.ArrayContainedBy = je;

const he = a;

function je(e) {
    return new he.FindOperator("arrayContainedBy", e);
}

var Pe = {};

"use strict";

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

var Me = Pe.ArrayContains = Re;

const Ee = a;

function Re(e) {
    return new Ee.FindOperator("arrayContains", e);
}

var Be = {};

"use strict";

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

var Se = Be.ArrayOverlap = Ne;

const Ie = a;

function Ne(e) {
    return new Ie.FindOperator("arrayOverlap", e);
}

var Fe = {};

"use strict";

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

var Te = Fe.Between = ke;

const we = a;

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

var Ce = {};

var De = {};

"use strict";

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

var Le = De.EqualOperator = void 0;

const Ae = a;

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

Le = De.EqualOperator = EqualOperator;

"use strict";

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

var xe = Ce.Equal = Ue;

const qe = De;

function Ue(e) {
    return new qe.EqualOperator(e);
}

var Qe = {};

"use strict";

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

var Xe = Qe.IsNull = ze;

const Ke = a;

function ze() {
    return new Ke.FindOperator("isNull", undefined, false);
}

var Ze = {};

"use strict";

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

var Je = Ze.LessThan = He;

const Ge = a;

function He(e) {
    return new Ge.FindOperator("lessThan", e);
}

var Ve = {};

"use strict";

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

var We = Ve.LessThanOrEqual = $e;

const Ye = a;

function $e(e) {
    return new Ye.FindOperator("lessThanOrEqual", e);
}

var et = {};

"use strict";

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

var tt = et.ILike = st;

const rt = a;

function st(e) {
    return new rt.FindOperator("ilike", e);
}

var nt = {};

"use strict";

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

var at = nt.Like = it;

const ot = a;

function it(e) {
    return new ot.FindOperator("like", e);
}

var ut = {};

"use strict";

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

var ct = ut.MoreThan = lt;

const dt = a;

function lt(e) {
    return new dt.FindOperator("moreThan", e);
}

var yt = {};

"use strict";

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

var pt = yt.MoreThanOrEqual = ft;

const vt = a;

function ft(e) {
    return new vt.FindOperator("moreThanOrEqual", e);
}

var Ot = {};

"use strict";

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

var mt = Ot.Not = gt;

const _t = a;

function gt(e) {
    return new _t.FindOperator("not", e);
}

var bt = {};

"use strict";

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

var ht = bt.Raw = Pt;

const jt = a;

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

var Mt = {};

"use strict";

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

var Et = Mt.JsonContains = Bt;

const Rt = a;

function Bt(e) {
    return new Rt.FindOperator("jsonContains", e);
}

var St = {};

"use strict";

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

var It = {};

"use strict";

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

var Nt = {};

"use strict";

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

var Ft = {};

"use strict";

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

var Tt = {};

"use strict";

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

var wt = {};

"use strict";

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

var kt = {};

"use strict";

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

var Ct = {};

"use strict";

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

var Dt = {};

"use strict";

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

var Lt = {};

"use strict";

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

var At = {};

"use strict";

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

var xt = {};

"use strict";

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

var qt = c();

const Ut = e(qt);

var Qt = d();

const Xt = e(Qt);

var Kt = {};

"use strict";

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

var zt = Kt.BaseEntity = void 0;

const Zt = f;

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);
        Zt.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();
    }
}

zt = Kt.BaseEntity = BaseEntity;

var Jt = {};

"use strict";

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

var Gt = {};

"use strict";

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

var Ht = {};

"use strict";

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

var Vt = {};

"use strict";

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

var Wt = {};

"use strict";

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

var Yt = {};

"use strict";

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

var $t = {};

"use strict";

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

var er = {};

"use strict";

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

var tr = {};

"use strict";

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

var rr = {};

"use strict";

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

var sr = {};

var nr = {};

"use strict";

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

var ar = nr.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 = nr;
    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;
        }
    });
})(sr);

const or = e(sr);

var ir = {};

"use strict";

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

var ur = {};

"use strict";

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

var cr = {};

"use strict";

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

var dr = {};

"use strict";

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

var lr = dr.NotBrackets = void 0;

const yr = O;

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

lr = dr.NotBrackets = NotBrackets;

var pr = _();

const vr = e(pr);

var fr = {};

"use strict";

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

var Or = fr.LegacyOracleNamingStrategy = void 0;

const mr = b;

const _r = E;

const gr = R;

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

Or = fr.LegacyOracleNamingStrategy = LegacyOracleNamingStrategy;

var br = {};

"use strict";

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

var hr = br.EntitySchema = void 0;

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

hr = br.EntitySchema = EntitySchema;

var jr = {};

"use strict";

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

var Pr = jr.EntitySchemaEmbeddedColumnOptions = void 0;

class EntitySchemaEmbeddedColumnOptions {}

Pr = jr.EntitySchemaEmbeddedColumnOptions = EntitySchemaEmbeddedColumnOptions;

var Mr = {};

"use strict";

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

var Er = Mr.EntitySchemaOptions = void 0;

class EntitySchemaOptions {}

Er = Mr.EntitySchemaOptions = EntitySchemaOptions;

const Rr = B.DataSource;

const Br = pr.MongoEntityManager;

export { ye as And, Oe as Any, be as ArrayContainedBy, Me as ArrayContains, Se as ArrayOverlap, zt as BaseEntity, Te as Between, Rr as DataSource, hr as EntitySchema, Pr as EntitySchemaEmbeddedColumnOptions, Er as EntitySchemaOptions, xe as Equal, Le as EqualOperator, tt as ILike, Xe as IsNull, Et as JsonContains, Or as LegacyOracleNamingStrategy, Je as LessThan, We as LessThanOrEqual, at as Like, Br as MongoEntityManager, ct as MoreThan, pt as MoreThanOrEqual, mt as Not, lr as NotBrackets, ht as Raw };