lakutata 2.0.25 → 2.0.26

package/src/providers/Database.mjs

@@ -0,0 +1,281 @@
+import { _ as t, a as e } from "../../vendor/Package.1.mjs";
+
+import { Configurable as r } from "../decorators/di/Configurable.mjs";
+
+import { Transient as i } from "../decorators/di/Lifetime.mjs";
+
+import { D as o } from "../../vendor/Package.2.mjs";
+
+import { Provider as s } from "../lib/core/Provider.mjs";
+
+import "../lib/base/internal/ObjectConfiguration.mjs";
+
+import "../constants/DIMetadataKey.mjs";
+
+import "../../vendor/Package.3.mjs";
+
+import "../../vendor/Package.4.mjs";
+
+import "../../vendor/Package.5.mjs";
+
+import "../lib/base/internal/DataValidator.mjs";
+
+import "node:util/types";
+
+import "../lib/validation/VLD.mjs";
+
+import "../../vendor/Package.6.mjs";
+
+import "url";
+
+import "util";
+
+import "../exceptions/dto/InvalidValueException.mjs";
+
+import "../lib/base/abstracts/Exception.mjs";
+
+import "../lib/base/internal/BasicInfo.mjs";
+
+import "../lib/helpers/As.mjs";
+
+import "../../vendor/Package.7.mjs";
+
+import "../../vendor/Package.8.mjs";
+
+import "../lib/base/internal/ThrowWarning.mjs";
+
+import "../lib/helpers/Templating.mjs";
+
+import "../lib/base/internal/CamelCase.mjs";
+
+import "../lib/helpers/NoCase.mjs";
+
+import "../../vendor/Package.9.mjs";
+
+import "../lib/helpers/IsHtml.mjs";
+
+import "../lib/helpers/IsXML.mjs";
+
+import "../constants/DTOMetadataKey.mjs";
+
+import "../lib/helpers/ObjectConstructor.mjs";
+
+import "../lib/helpers/ObjectParentConstructors.mjs";
+
+import "../lib/helpers/ObjectParentConstructor.mjs";
+
+import "../lib/helpers/ObjectPrototype.mjs";
+
+import "../lib/base/internal/ObjectLifetime.mjs";
+
+import "../exceptions/di/LifetimeLockedException.mjs";
+
+import "../../vendor/Package.22.mjs";
+
+import "../../vendor/Package.72.mjs";
+
+import "../../vendor/Package.10.mjs";
+
+import "buffer";
+
+import "module";
+
+import "tty";
+
+import "../../vendor/Package.11.mjs";
+
+import "fs";
+
+import "path";
+
+import "os";
+
+import "events";
+
+import "stream";
+
+import "../../vendor/Package.12.mjs";
+
+import "crypto";
+
+import "fs/promises";
+
+import "../../vendor/Package.73.mjs";
+
+import "node:url";
+
+import "node:path";
+
+import "node:fs";
+
+import "node:fs/promises";
+
+import "node:events";
+
+import "node:stream";
+
+import "node:string_decoder";
+
+import "../../vendor/Package.13.mjs";
+
+import "../lib/base/async-constructor/AsyncConstructor.mjs";
+
+import "../lib/base/async-constructor/Append.mjs";
+
+import "../lib/helpers/IsPromiseLike.mjs";
+
+import "../lib/helpers/IsPromise.mjs";
+
+import "util/types";
+
+import "../exceptions/MethodNotFoundException.mjs";
+
+import "../lib/ioc/DependencyInjectionContainer.mjs";
+
+import "../lib/ioc/Errors.mjs";
+
+import "../exceptions/di/DependencyInjectionException.mjs";
+
+import "../lib/base/internal/ConstructorSymbol.mjs";
+
+import "node:crypto";
+
+import "../lib/ioc/InjectionMode.mjs";
+
+import "../lib/ioc/Lifetime.mjs";
+
+import "../lib/ioc/ListModules.mjs";
+
+import "../lib/ioc/Utils.mjs";
+
+import "../lib/ioc/FunctionTokenizer.mjs";
+
+import "../lib/ioc/LoadModules.mjs";
+
+import "../lib/ioc/Resolvers.mjs";
+
+import "../lib/ioc/ParamParser.mjs";
+
+import "../lib/base/internal/ObjectWeakRefs.mjs";
+
+import "../lib/base/internal/ConfigurableRecordsInjection.mjs";
+
+import "../lib/base/internal/ObjectInjection.mjs";
+
+import "../lib/base/internal/ObjectContainer.mjs";
+
+import "../lib/helpers/DevNull.mjs";
+
+import "../decorators/dto/Expect.mjs";
+
+import "../decorators/dto/IndexSignature.mjs";
+
+import "../decorators/dto/Accept.mjs";
+
+import "../lib/base/internal/MethodValidation.mjs";
+
+import "../exceptions/dto/InvalidMethodAcceptException.mjs";
+
+import "../exceptions/dto/InvalidMethodReturnException.mjs";
+
+import "../lib/helpers/IsEmptyObject.mjs";
+
+const a = t => ({
+    class: n,
+    options: t
+});
+
+let n = class Database extends s {
+    #t;
+    get datasource() {
+        return this.#t;
+    }
+    get driver() {
+        return this.datasource.driver;
+    }
+    get manager() {
+        return this.datasource.manager;
+    }
+    set namingStrategy(t) {
+        this.datasource.namingStrategy = t;
+    }
+    get namingStrategy() {
+        return this.datasource.namingStrategy;
+    }
+    get subscribers() {
+        return this.datasource.subscribers;
+    }
+    get entityMetadatas() {
+        return this.datasource.entityMetadatas;
+    }
+    get entityMetadatasMap() {
+        return this.datasource.entityMetadatasMap;
+    }
+    get queryResultCache() {
+        return this.datasource.queryResultCache;
+    }
+    async init() {
+        const t = this.entities ? this.entities : [];
+        const e = {
+            ...this.options,
+            entities: t
+        };
+        this.#t = await new o.DataSource(this.options).initialize();
+    }
+    async destroy() {
+        await this.datasource.destroy();
+    }
+    async synchronize(t) {
+        return await this.datasource.synchronize(t);
+    }
+    async runMigrations(t) {
+        return await this.datasource.runMigrations(t);
+    }
+    async undoLastMigration(t) {
+        return await this.datasource.undoLastMigration(t);
+    }
+    async showMigrations() {
+        return await this.datasource.showMigrations();
+    }
+    hasMetadata(t) {
+        return this.datasource.hasMetadata(t);
+    }
+    getMetadata(t) {
+        return this.datasource.getMetadata(t);
+    }
+    getRepository(t) {
+        return this.datasource.getRepository(t);
+    }
+    getTreeRepository(t) {
+        return this.datasource.getTreeRepository(t);
+    }
+    getMongoRepository(t) {
+        return this.datasource.getMongoRepository(t);
+    }
+    async transaction(t, e) {
+        return e ? await this.datasource.transaction(t, e) : await this.datasource.transaction(t);
+    }
+    async query(t, e, r) {
+        return await this.datasource.query(t, e, r);
+    }
+    createQueryBuilder(t, e, r) {
+        return arguments.length > 1 ? this.datasource.createQueryBuilder(t, e, r) : this.datasource.createQueryBuilder(t);
+    }
+    createQueryRunner(t) {
+        return this.datasource.createQueryRunner(t);
+    }
+    getManyToManyMetadata(t, e) {
+        return this.datasource.getManyToManyMetadata(t, e);
+    }
+    createEntityManager(t) {
+        return this.datasource.createEntityManager(t);
+    }
+};
+
+t([ r(), e("design:type", Object) ], n.prototype, "options", void 0);
+
+t([ r(), e("design:type", Object) ], n.prototype, "entities", void 0);
+
+n = t([ i() ], n);
+
+export { a as BuildDatabaseOptions, n as Database };

package/vendor/Package.10.cjs

@@ -1,11 +1,85 @@
 "use strict";
 
-require("os");
+require("./Package.4.cjs");
 
-require("path");
+const e = require("buffer");
 
-require("stream");
+require("module");
 
-require("events");
+require("tty");
 
-require("fs");
+const r = e => e && e.__esModule ? e : {
+    default: e
+};
+
+const t = r(e);
+
+var n = {
+    exports: {}
+};
+
+var o = n.exports;
+
+var u;
+
+function f() {
+    if (u) return n.exports;
+    u = 1;
+    (function(e, r) {
+        var n = t.default;
+        var o = n.Buffer;
+        function u(e, r) {
+            for (var t in e) {
+                r[t] = e[t];
+            }
+        }
+        if (o.from && o.alloc && o.allocUnsafe && o.allocUnsafeSlow) {
+            e.exports = n;
+        } else {
+            u(n, r);
+            r.Buffer = f;
+        }
+        function f(e, r, t) {
+            return o(e, r, t);
+        }
+        f.prototype = Object.create(o.prototype);
+        u(o, f);
+        f.from = function(e, r, t) {
+            if (typeof e === "number") {
+                throw new TypeError("Argument must not be a number");
+            }
+            return o(e, r, t);
+        };
+        f.alloc = function(e, r, t) {
+            if (typeof e !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            var n = o(e);
+            if (r !== undefined) {
+                if (typeof t === "string") {
+                    n.fill(r, t);
+                } else {
+                    n.fill(r);
+                }
+            } else {
+                n.fill(0);
+            }
+            return n;
+        };
+        f.allocUnsafe = function(e) {
+            if (typeof e !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            return o(e);
+        };
+        f.allocUnsafeSlow = function(e) {
+            if (typeof e !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            return n.SlowBuffer(e);
+        };
+    })(n, n.exports);
+    return n.exports;
+}
+
+exports.requireSafeBuffer = f;

package/vendor/Package.10.mjs

@@ -1,9 +1,77 @@
-import "os";
+import "./Package.4.mjs";
 
-import "path";
+import r from "buffer";
 
-import "stream";
+import "module";
 
-import "events";
+import "tty";
 
-import "fs";
+var e = {
+    exports: {}
+};
+
+var t = e.exports;
+
+var o;
+
+function n() {
+    if (o) return e.exports;
+    o = 1;
+    (function(e, t) {
+        var o = r;
+        var n = o.Buffer;
+        function f(r, e) {
+            for (var t in r) {
+                e[t] = r[t];
+            }
+        }
+        if (n.from && n.alloc && n.allocUnsafe && n.allocUnsafeSlow) {
+            e.exports = o;
+        } else {
+            f(o, t);
+            t.Buffer = u;
+        }
+        function u(r, e, t) {
+            return n(r, e, t);
+        }
+        u.prototype = Object.create(n.prototype);
+        f(n, u);
+        u.from = function(r, e, t) {
+            if (typeof r === "number") {
+                throw new TypeError("Argument must not be a number");
+            }
+            return n(r, e, t);
+        };
+        u.alloc = function(r, e, t) {
+            if (typeof r !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            var o = n(r);
+            if (e !== undefined) {
+                if (typeof t === "string") {
+                    o.fill(e, t);
+                } else {
+                    o.fill(e);
+                }
+            } else {
+                o.fill(0);
+            }
+            return o;
+        };
+        u.allocUnsafe = function(r) {
+            if (typeof r !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            return n(r);
+        };
+        u.allocUnsafeSlow = function(r) {
+            if (typeof r !== "number") {
+                throw new TypeError("Argument must be a number");
+            }
+            return o.SlowBuffer(r);
+        };
+    })(e, e.exports);
+    return e.exports;
+}
+
+export { n as r };

package/vendor/Package.11.cjs

@@ -1,3 +1,11 @@
 "use strict";
 
-require("crypto");
+require("fs");
+
+require("path");
+
+require("os");
+
+require("events");
+
+require("stream");

package/vendor/Package.11.mjs

@@ -1 +1,9 @@
-import "crypto";
+import "fs";
+
+import "path";
+
+import "os";
+
+import "events";
+
+import "stream";