lakutata 0.2.1-proto.21 → 0.2.1-proto.22

package/com.cjs

@@ -0,0 +1,239 @@
+"use strict";
+
+Object.defineProperty(exports, Symbol.toStringTag, {
+    value: "Module"
+});
+
+const e = require("./src/components/Database.cjs");
+
+const r = require("./src/components/Entrypoint.cjs");
+
+const i = require("./src/lib/base/Context.cjs");
+
+const c = require("./src/lib/context/CLIContext.cjs");
+
+const s = require("./src/lib/context/HTTPContext.cjs");
+
+const t = require("./src/lib/context/ServiceContext.cjs");
+
+require("./vendor/Package.1.cjs");
+
+require("./src/decorators/di/Configurable.cjs");
+
+require("./src/lib/base/internal/ObjectConfiguration.cjs");
+
+require("./src/constants/metadata-keys/DIMetadataKey.cjs");
+
+require("./vendor/Package.4.cjs");
+
+require("./vendor/Package.5.cjs");
+
+require("./vendor/Package.2.cjs");
+
+require("./src/lib/base/internal/DataValidator.cjs");
+
+require("node:util/types");
+
+require("./src/lib/validation/VLD.cjs");
+
+require("./vendor/Package.6.cjs");
+
+require("url");
+
+require("./vendor/Package.7.cjs");
+
+require("util");
+
+require("./src/exceptions/dto/InvalidValueException.cjs");
+
+require("./src/lib/base/abstracts/Exception.cjs");
+
+require("./src/lib/base/internal/BasicInfo.cjs");
+
+require("./src/lib/functions/As.cjs");
+
+require("./src/lib/functions/Templating.cjs");
+
+require("./src/lib/base/internal/CamelCase.cjs");
+
+require("./src/lib/functions/NoCase.cjs");
+
+require("./vendor/Package.8.cjs");
+
+require("./src/lib/functions/IsHtml.cjs");
+
+require("./src/lib/functions/IsXML.cjs");
+
+require("./src/constants/metadata-keys/DTOMetadataKey.cjs");
+
+require("./src/lib/functions/ObjectConstructor.cjs");
+
+require("./src/lib/functions/ObjectParentConstructors.cjs");
+
+require("./src/lib/functions/ObjectParentConstructor.cjs");
+
+require("./src/lib/functions/ObjectPrototype.cjs");
+
+require("./src/lib/core/Component.cjs");
+
+require("./vendor/Package.3.cjs");
+
+require("./src/lib/base/async-constructor/AsyncConstructor.cjs");
+
+require("./src/lib/base/async-constructor/Append.cjs");
+
+require("./src/lib/functions/IsPromiseLike.cjs");
+
+require("./src/lib/functions/IsPromise.cjs");
+
+require("util/types");
+
+require("./src/decorators/di/Lifetime.cjs");
+
+require("./src/lib/base/internal/ObjectLifetime.cjs");
+
+require("./src/exceptions/di/LifetimeLockedException.cjs");
+
+require("./src/exceptions/MethodNotFoundException.cjs");
+
+require("./src/lib/ioc/DependencyInjectionContainer.cjs");
+
+require("./src/lib/ioc/Errors.cjs");
+
+require("./src/exceptions/di/DependencyInjectionException.cjs");
+
+require("./src/lib/base/internal/ConstructorSymbol.cjs");
+
+require("node:crypto");
+
+require("./src/lib/ioc/InjectionMode.cjs");
+
+require("./src/lib/ioc/Lifetime.cjs");
+
+require("./src/lib/ioc/ListModules.cjs");
+
+require("./vendor/Package.9.cjs");
+
+require("os");
+
+require("stream");
+
+require("events");
+
+require("./vendor/Package.10.cjs");
+
+require("path");
+
+require("fs");
+
+require("./src/lib/ioc/Utils.cjs");
+
+require("./src/lib/ioc/FunctionTokenizer.cjs");
+
+require("./src/lib/ioc/LoadModules.cjs");
+
+require("./src/lib/ioc/Resolvers.cjs");
+
+require("./src/lib/ioc/ParamParser.cjs");
+
+require("./src/lib/base/internal/ObjectWeakRefs.cjs");
+
+require("./src/lib/base/internal/ConfigurableRecordsInjection.cjs");
+
+require("./src/lib/base/internal/ObjectInjection.cjs");
+
+require("./src/lib/base/internal/ObjectContainer.cjs");
+
+require("./src/lib/functions/DevNull.cjs");
+
+require("./src/decorators/dto/Expect.cjs");
+
+require("./src/decorators/dto/IndexSignature.cjs");
+
+require("./src/decorators/dto/Accept.cjs");
+
+require("./src/lib/base/internal/MethodValidation.cjs");
+
+require("./src/exceptions/dto/InvalidMethodAcceptException.cjs");
+
+require("./src/exceptions/dto/InvalidMethodReturnException.cjs");
+
+require("./src/lib/functions/IsEmptyObject.cjs");
+
+require("./src/lib/base/EventEmitter.cjs");
+
+require("./src/lib/core/Provider.cjs");
+
+require("./vendor/Package.15.cjs");
+
+require("./vendor/Package.14.cjs");
+
+require("./vendor/Package.13.cjs");
+
+require("./vendor/Package.11.cjs");
+
+require("crypto");
+
+require("tty");
+
+require("module");
+
+require("buffer");
+
+require("fs/promises");
+
+require("string_decoder");
+
+require("./src/lib/base/internal/ControllerEntrypoint.cjs");
+
+require("./src/lib/functions/ObjectHash.cjs");
+
+require("./src/lib/functions/GetObjectNestingDepth.cjs");
+
+require("./src/exceptions/InvalidActionPatternDepthException.cjs");
+
+require("./src/lib/base/internal/PatternManager.cjs");
+
+require("./src/exceptions/ControllerActionNotFoundException.cjs");
+
+require("./src/exceptions/DestroyRuntimeContainerException.cjs");
+
+require("./src/lib/functions/GetObjectPropertyPaths.cjs");
+
+require("./src/lib/functions/UniqueArray.cjs");
+
+require("node:http");
+
+Object.defineProperty(exports, "Database", {
+    enumerable: true,
+    get: () => e.Database
+});
+
+exports.CLIEntrypointBuilder = r.CLIEntrypointBuilder;
+
+Object.defineProperty(exports, "Entrypoint", {
+    enumerable: true,
+    get: () => r.Entrypoint
+});
+
+exports.EntrypointBuilder = r.EntrypointBuilder;
+
+exports.HTTPEntrypointBuilder = r.HTTPEntrypointBuilder;
+
+exports.ServiceEntrypointBuilder = r.ServiceEntrypointBuilder;
+
+Object.defineProperty(exports, "BaseContext", {
+    enumerable: true,
+    get: () => i.BaseContext
+});
+
+Object.defineProperty(exports, "ContextType", {
+    enumerable: true,
+    get: () => i.ContextType
+});
+
+exports.CLIContext = c.CLIContext;
+
+exports.HTTPContext = s.HTTPContext;
+
+exports.ServiceContext = t.ServiceContext;

package/{src/exports/COM.d.ts → com.d.cts}

@@ -1,9 +1,9 @@
-import { c as Component, A as ActionPattern, d as Controller, I as IBaseObjectConstructor, b as Module, i as CLIContext, H as HTTPContext, S as ServiceContext } from '../../vendor/TypeDef.3.js';
-export { k as BaseContext, j as ContextType } from '../../vendor/TypeDef.3.js';
-import { i as DataSourceOptions, D as DataSource, s as Driver, j as EntityManager, a2 as NamingStrategyInterface, aq as EntitySubscriberInterface, r as EntityMetadata, E as EntityTarget, an as QueryResultCache, v as Migration, O as ObjectLiteral, k as Repository, l as TreeRepository, n as MongoRepository, ap as IsolationLevel, Q as QueryRunner, o as SelectQueryBuilder, gG as ReplicationMode } from '../../vendor/TypeDef.8.js';
-import '../../vendor/TypeDef.1.js';
-import { D as DTO, J as JSONSchema } from '../../vendor/TypeDef.2.js';
-import { I as IPatRun } from '../../vendor/TypeDef.7.js';
+import { c as Component, A as ActionPattern, d as Controller, I as IBaseObjectConstructor, b as Module, i as CLIContext, H as HTTPContext, S as ServiceContext } from './vendor/TypeDef.3.cjs';
+export { k as BaseContext, j as ContextType } from './vendor/TypeDef.3.cjs';
+import { i as DataSourceOptions, D as DataSource, s as Driver, j as EntityManager, a2 as NamingStrategyInterface, aq as EntitySubscriberInterface, r as EntityMetadata, E as EntityTarget, an as QueryResultCache, v as Migration, O as ObjectLiteral, k as Repository, l as TreeRepository, n as MongoRepository, ap as IsolationLevel, Q as QueryRunner, o as SelectQueryBuilder, gG as ReplicationMode } from './vendor/TypeDef.8.cjs';
+import './vendor/TypeDef.1.cjs';
+import { D as DTO, J as JSONSchema } from './vendor/TypeDef.2.cjs';
+import { I as IPatRun } from './vendor/TypeDef.7.cjs';
 import 'node:http';
 import 'fs';
 import 'tls';

package/com.d.mts

@@ -0,0 +1,325 @@
+import { c as Component, A as ActionPattern, d as Controller, I as IBaseObjectConstructor, b as Module, i as CLIContext, H as HTTPContext, S as ServiceContext } from './vendor/TypeDef.3.mjs';
+export { k as BaseContext, j as ContextType } from './vendor/TypeDef.3.mjs';
+import { i as DataSourceOptions, D as DataSource, s as Driver, j as EntityManager, a2 as NamingStrategyInterface, aq as EntitySubscriberInterface, r as EntityMetadata, E as EntityTarget, an as QueryResultCache, v as Migration, O as ObjectLiteral, k as Repository, l as TreeRepository, n as MongoRepository, ap as IsolationLevel, Q as QueryRunner, o as SelectQueryBuilder, gG as ReplicationMode } from './vendor/TypeDef.8.mjs';
+import './vendor/TypeDef.1.mjs';
+import { D as DTO, J as JSONSchema } from './vendor/TypeDef.2.mjs';
+import { I as IPatRun } from './vendor/TypeDef.7.mjs';
+import 'node:http';
+import 'fs';
+import 'tls';
+import 'net';
+import 'dns';
+import 'events';
+import 'stream';
+
+/**
+ * Database component
+ */
+declare class Database extends Component {
+    #private;
+    /**
+     * Connection options
+     */
+    protected readonly options: DataSourceOptions;
+    /**
+     * Datasource instance
+     * @protected
+     */
+    protected get datasource(): DataSource;
+    /**
+     * Connection driver
+     */
+    get driver(): Driver;
+    /**
+     * EntityManager of this connection.
+     */
+    get manager(): EntityManager;
+    /**
+     * Set naming strategy used in the connection.
+     * @param instance
+     */
+    set namingStrategy(instance: NamingStrategyInterface);
+    /**
+     * Get naming strategy used in the connection.
+     */
+    get namingStrategy(): NamingStrategyInterface;
+    /**
+     * Entity subscriber instances that are registered for this connection.
+     */
+    get subscribers(): EntitySubscriberInterface<any>[];
+    /**
+     * All entity metadatas that are registered for this connection.
+     */
+    get entityMetadatas(): EntityMetadata[];
+    /**
+     * All entity metadatas that are registered for this connection.
+     * This is a copy of #.entityMetadatas property -> used for more performant searches.
+     */
+    get entityMetadatasMap(): Map<EntityTarget<any>, EntityMetadata>;
+    /**
+     * Used to work with query result cache.
+     */
+    get queryResultCache(): QueryResultCache | undefined;
+    /**
+     * Initializer
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Destroyer
+     * @protected
+     */
+    protected destroy(): Promise<void>;
+    /**
+     * Creates database schema for all entities registered in this connection.
+     * Can be used only after connection to the database is established.
+     *
+     * @param dropBeforeSync If set to true then it drops the database with all its tables and data
+     */
+    synchronize(dropBeforeSync?: boolean): Promise<void>;
+    /**
+     * Runs all pending migrations.
+     * Can be used only after connection to the database is established.
+     * @param options
+     */
+    runMigrations(options?: {
+        transaction?: 'all' | 'none' | 'each';
+        fake?: boolean;
+    }): Promise<Migration[]>;
+    /**
+     * Reverts last executed migration.
+     * Can be used only after connection to the database is established.
+     * @param options
+     */
+    undoLastMigration(options?: {
+        transaction?: 'all' | 'none' | 'each';
+        fake?: boolean;
+    }): Promise<void>;
+    /**
+     * Lists all migrations and whether they have been run.
+     * Returns true if there are pending migrations
+     */
+    showMigrations(): Promise<boolean>;
+    /**
+     * Checks if entity metadata exist for the given entity class, target name or table name.
+     * @param target
+     */
+    hasMetadata(target: EntityTarget<any>): boolean;
+    /**
+     * Gets entity metadata for the given entity class or schema name.
+     * @param target
+     */
+    getMetadata(target: EntityTarget<any>): EntityMetadata;
+    /**
+     * Gets repository for the given entity.
+     * @param target
+     */
+    getRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): Repository<Entity>;
+    /**
+     * Gets tree repository for the given entity class or name.
+     * Only tree-type entities can have a TreeRepository, like ones decorated with @Tree decorator.
+     * @param target
+     */
+    getTreeRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): TreeRepository<Entity>;
+    /**
+     * Gets mongodb-specific repository for the given entity class or name.
+     * Works only if connection is mongodb-specific.
+     * @param target
+     */
+    getMongoRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): MongoRepository<Entity>;
+    /**
+     * Wraps given function execution (and all operations made there) into a transaction.
+     * All database operations must be executed using provided entity manager.
+     * @param runInTransaction
+     */
+    transaction<T>(runInTransaction: (entityManager: EntityManager) => Promise<T>): Promise<T>;
+    transaction<T>(isolationLevel: IsolationLevel, runInTransaction: (entityManager: EntityManager) => Promise<T>): Promise<T>;
+    /**
+     * Executes raw SQL query and returns raw database results.
+     * @param query
+     * @param parameters
+     * @param queryRunner
+     */
+    query<T = any>(query: string, parameters?: any[], queryRunner?: QueryRunner): Promise<T>;
+    /**
+     * Creates a new query builder that can be used to build a SQL query.
+     * @param entityClass
+     * @param alias
+     * @param queryRunner
+     */
+    createQueryBuilder<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, alias: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
+    createQueryBuilder(queryRunner?: QueryRunner): SelectQueryBuilder<any>;
+    /**
+     * Creates a query runner used for perform queries on a single database connection.
+     * Using query runners you can control your queries to execute using single database connection and
+     * manually control your database transaction.
+     *
+     * Mode is used in replication mode and indicates whatever you want to connect
+     * to master database or any of slave databases.
+     * If you perform writes you must use master database,
+     * if you perform reads you can use slave databases.
+     *
+     * @param mode
+     */
+    createQueryRunner(mode?: ReplicationMode): QueryRunner;
+    /**
+     * Gets entity metadata of the junction table (many-to-many table).
+     * @param entityTarget
+     * @param relationPropertyPath
+     */
+    getManyToManyMetadata(entityTarget: EntityTarget<any>, relationPropertyPath: string): EntityMetadata | undefined;
+    /**
+     * Creates an Entity Manager for the current connection with the help of the EntityManagerFactory.
+     * @param queryRunner
+     */
+    createEntityManager(queryRunner?: QueryRunner): EntityManager;
+}
+
+type ActionPatternMap = Map<ActionPattern, ActionDetails>;
+type ActionDetails<ClassPrototype extends Controller = Controller, DTOConstructor extends typeof DTO = typeof DTO> = {
+    pattern: ActionPattern;
+    constructor: IBaseObjectConstructor<ClassPrototype>;
+    method: string | number | symbol;
+    dtoConstructor: DTOConstructor;
+    jsonSchema: JSONSchema;
+};
+
+type PatternManagerOptions = {
+    globMatch?: boolean;
+};
+declare class PatternManager implements IPatRun {
+    #private;
+    constructor(options?: PatternManagerOptions);
+    /**
+     * Register a pattern, and the object that will be returned if an input matches.
+     * Both keys and values are considered to be strings.
+     * Other types are converted to strings.
+     * @param pattern
+     * @param obj
+     */
+    add(pattern: Record<string, any>, obj: any): this;
+    /**
+     * Remove this pattern, and it's object, from the matcher.
+     * @param pattern
+     */
+    remove(pattern: Record<string, any>): this;
+    /**
+     * Return the unique match for this subject, or null if not found.
+     * The properties of the subject are matched against the patterns previously added, and the most specifc pattern wins.
+     * Unknown properties in the subject are ignored.
+     * You can optionally provide a second boolean parameter, exact. If true, then all properties of the subject must match.
+     *
+     * If the optional third boolean parameter collect is true, then find returns an array of all sub matches
+     * (i.e. run find on each element of the power set of the subject pattern elements, and collate in breadth first order).
+     * Thus, {a:1,b:2} will generate {a:1},{b:2},{a:1,b:2} searches.
+     * If exact is true, only increasing sub patterns in lexicographical order are chosen.
+     * Thus, {a:1,b:2} will generate {a:1},{a:1,b:2}, omitting {b:2}. (You probably want to set exact to false!).
+     * @param subject
+     * @param exact
+     */
+    find(subject: Record<string, any>, exact?: boolean): any;
+    /**
+     * Return the list of registered patterns that contain this partial pattern.
+     * You can use wildcards for property values.
+     * Omitted values are not equivalent to a wildcard of "*", you must specify each property explicitly.
+     * @param partialPattern
+     */
+    list(partialPattern?: Record<string, any> | undefined): {
+        match: Record<string, any>;
+        data: any;
+    }[];
+    /**
+     * Generate a string representation of the decision tree for debugging.
+     */
+    toJSON(): string;
+}
+
+type CLIEntrypoint = (module: Module, cliMap: CLIMap, handler: CLIEntrypointHandler) => void;
+type HTTPEntrypoint = (module: Module, routeMap: HTTPRouteMap, handler: HTTPEntrypointHandler) => void;
+type ServiceEntrypoint = (module: Module, handler: ServiceEntrypointHandler) => void;
+type CLIMap = Map<string, JSONSchema>;
+type HTTPRouteMap<HTTPMethods = string> = Map<string, Set<HTTPMethods>>;
+type CLIEntrypointHandler<T = unknown> = (context: CLIContext, abortController?: AbortController) => Promise<T>;
+type HTTPEntrypointHandler<T = unknown> = (context: HTTPContext, abortController?: AbortController) => Promise<T>;
+type ServiceEntrypointHandler<T = unknown> = (context: ServiceContext, abortController?: AbortController) => Promise<T>;
+type EntrypointOptions = {
+    cli?: CLIEntrypoint | CLIEntrypoint[];
+    http?: HTTPEntrypoint | HTTPEntrypoint[];
+    service?: ServiceEntrypoint | ServiceEntrypoint[];
+};
+declare const CLIEntrypointBuilder: (entrypoint: CLIEntrypoint) => CLIEntrypoint;
+declare const HTTPEntrypointBuilder: (entrypoint: HTTPEntrypoint) => HTTPEntrypoint;
+declare const ServiceEntrypointBuilder: (entrypoint: ServiceEntrypoint) => ServiceEntrypoint;
+declare const EntrypointBuilder: (options: EntrypointOptions) => EntrypointOptions;
+/**
+ * Entrypoint Component
+ */
+declare class Entrypoint extends Component {
+    protected readonly CLIActionPatternMap: ActionPatternMap;
+    protected readonly HTTPActionPatternMap: ActionPatternMap;
+    protected readonly ServiceActionPatternMap: ActionPatternMap;
+    protected readonly CLIActionPatternManager: PatternManager;
+    protected readonly HTTPActionPatternManager: PatternManager;
+    protected readonly ServiceActionPatternManager: PatternManager;
+    cli?: CLIEntrypoint | CLIEntrypoint[];
+    http?: HTTPEntrypoint | HTTPEntrypoint[];
+    service?: ServiceEntrypoint | ServiceEntrypoint[];
+    /**
+     * Initializer
+     * @protected
+     */
+    protected init(): Promise<void>;
+    /**
+     * Run controller's method and return its result (without AbortController)
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @protected
+     */
+    protected runControllerMethodWithoutAbortController<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor): Promise<unknown>;
+    /**
+     * Run controller's method and return its result (with AbortController)
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @param abortController
+     * @protected
+     */
+    protected runControllerMethodWithAbortController<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor, abortController: AbortController): Promise<unknown>;
+    /**
+     * Run controller's method and return its result
+     * @param details
+     * @param context
+     * @param dtoConstructor
+     * @param abortController
+     * @protected
+     */
+    protected runControllerMethod<DTOConstructor extends typeof DTO = typeof DTO>(details: ActionDetails, context: CLIContext | HTTPContext | ServiceContext, dtoConstructor: DTOConstructor, abortController?: AbortController): Promise<unknown>;
+    /**
+     * Register
+     * @param eps
+     * @param registerFunc
+     * @protected
+     */
+    protected register<T>(eps: any | any[] | undefined, registerFunc: (entrypoint: T) => void): void;
+    /**
+     * Register CLI entrypoint
+     * @param entrypoint
+     * @protected
+     */
+    protected registerCLIEntrypoint(entrypoint: CLIEntrypoint): void;
+    /**
+     * Register http entrypoint
+     * @param entrypoint
+     * @protected
+     */
+    protected registerHTTPEntrypoint(entrypoint: HTTPEntrypoint): void;
+    /**
+     * Register service entrypoint
+     * @param entrypoint
+     * @protected
+     */
+    protected registerServiceEntrypoint(entrypoint: ServiceEntrypoint): void;
+}
+
+export { CLIContext, type CLIEntrypoint, CLIEntrypointBuilder, type CLIEntrypointHandler, type CLIMap, Database, Entrypoint, EntrypointBuilder, type EntrypointOptions, HTTPContext, type HTTPEntrypoint, HTTPEntrypointBuilder, type HTTPEntrypointHandler, type HTTPRouteMap, ServiceContext, type ServiceEntrypoint, ServiceEntrypointBuilder, type ServiceEntrypointHandler };