@venizia/ignis-kernel 0.2.0-0

package/dist/esm/helpers/inversion/registry.d.ts

@@ -0,0 +1,449 @@
+import type { AnyType, TClass } from '@venizia/ignis-helpers/common';
+import { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
+import type { IModelRegistryEntry, IRepositoryBinding } from './common/types.js';
+declare const BaseRegistry: {
+    new (...args: any[]): {
+        addRpc<Target extends object = object>(opts: {
+            target: Target;
+            methodName: string | symbol;
+            configs: import("./common/index.js").IRpcMetadata;
+        }): void;
+        getRpcs<Target extends object = object>(opts: {
+            target: Target;
+        }): Map<string | symbol, import("./common/index.js").IRpcMetadata> | undefined;
+        getRpc<Target extends object = object>(opts: {
+            target: Target;
+            methodName: string | symbol;
+        }): import("./common/index.js").IRpcMetadata | undefined;
+        hasRpcs<Target extends object = object>(opts: {
+            target: Target;
+        }): boolean;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+    };
+} & {
+    new (...args: any[]): {
+        getRoutes<Target extends object = object>(opts: {
+            target: Target;
+        }): Map<string | symbol, import("../../index.js").IAuthRouteConfig> | undefined;
+        getRoute<Target extends object = object>(opts: {
+            target: Target;
+            methodName: string | symbol;
+        }): import("../../index.js").IAuthRouteConfig | undefined;
+        hasRoutes<Target extends object = object>(opts: {
+            target: Target;
+        }): boolean;
+        addRoute<Target extends object = object>(opts: {
+            target: Target;
+            methodName: string | symbol;
+            configs: import("../../index.js").IAuthRouteConfig;
+        }): void;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+    };
+} & {
+    new (...args: any[]): {
+        setControllerMetadata<Target extends object = object>(opts: {
+            target: Target;
+            metadata: import("./common/index.js").TControllerMetadata;
+        }): void;
+        getControllerMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): import("./common/index.js").TControllerMetadata | undefined;
+        getRestControllerMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): import("./common/index.js").IRestControllerMetadata | undefined;
+        getGrpcControllerMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): import("./common/index.js").IGrpcControllerMetadata | undefined;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+    };
+} & {
+    new (...args: any[]): {
+        repositoryBindings: Map<string, IRepositoryBinding<import("../../index.js").AbstractEntity>>;
+        datasourceModels: Map<string, Set<TClass<AnyType>>>;
+        setRepositoryMetadata<Target extends object = object, Model extends import("../../index.js").AbstractEntity = import("../../index.js").AbstractEntity<unknown>, DataSource extends import("../../index.js").IDataSource = import("../../index.js").IDataSource<{}, import("../../index.js").TAnyDataSourceSchema, {}>>(opts: {
+            target: Target;
+            metadata: import("./common/index.js").IRepositoryMetadata<Model, DataSource>;
+        }): void;
+        getRepositoryMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): (import("./common/index.js").IRepositoryMetadata<import("../../index.js").AbstractEntity<unknown>, import("../../index.js").IDataSource<{}, import("../../index.js").TAnyDataSourceSchema, {}>> & {
+            _resolved?: import("./common/index.js").IResolvedRepositoryMetadata;
+        }) | undefined;
+        registerRepositoryBinding<Model extends import("../../index.js").AbstractEntity = import("../../index.js").AbstractEntity<unknown>, DataSource extends import("../../index.js").IDataSource = import("../../index.js").IDataSource<{}, import("../../index.js").TAnyDataSourceSchema, {}>>(opts: IRepositoryBinding<Model, DataSource>): void;
+        getRepositoryBinding(opts: {
+            name: string;
+        }): IRepositoryBinding<import("../../index.js").AbstractEntity> | undefined;
+        resolveModelRelations(modelMeta: IModelRegistryEntry): unknown;
+        getModels(opts: {
+            dataSource: string | TClass<import("../../index.js").IDataSource>;
+        }): {
+            tableName: string;
+            schema: unknown;
+            relations?: unknown;
+        }[];
+        getModelClasses(opts: {
+            dataSource: string | TClass<import("../../index.js").IDataSource>;
+        }): Array<TClass<unknown>>;
+        resolveModelKey(opts: {
+            modelClass: TClass<AnyType>;
+        }): string;
+        buildSchema(opts: {
+            dataSource: string | TClass<import("../../index.js").IDataSource>;
+        }): {
+            schema: Record<string, unknown>;
+            relations: Record<string, unknown>;
+        };
+        hasModels(opts: {
+            dataSource: string | TClass<import("../../index.js").IDataSource>;
+        }): boolean;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+        modelRegistry: Map<string, IModelRegistryEntry>;
+        getModelMetadata: (opts: {
+            target: object;
+        }) => import("./common/index.js").IModelMetadata | undefined;
+    };
+} & {
+    new (...args: any[]): {
+        modelRegistry: Map<string, IModelRegistryEntry>;
+        setModelMetadata<Target extends object = object>(opts: {
+            target: Target;
+            metadata: import("./common/index.js").IModelMetadata;
+        }): void;
+        getModelMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): import("./common/index.js").IModelMetadata | undefined;
+        registerModel<Model extends import("../../index.js").AbstractEntity = import("../../index.js").AbstractEntity<unknown>>(opts: {
+            target: import("./common/index.js").TDecoratorModelTarget<Model>;
+            metadata: import("./common/index.js").IModelMetadata;
+        }): void;
+        getModelEntry(opts: {
+            name: string;
+        }): IModelRegistryEntry | undefined;
+        getAllModels(): Map<string, IModelRegistryEntry>;
+        getModelAuthorizeSettings(opts: {
+            name: string;
+        }): import("./common/index.js").IModelAuthorizeSettings | undefined;
+        getAuthorizeModelPrincipals(opts: {
+            format: "array";
+        }): string[];
+        getAuthorizeModelPrincipals(opts: {
+            format: "record";
+        }): Record<string, string>;
+        getAuthorizeModelSettings(opts: {
+            format: "array";
+        }): {
+            name: string;
+            authorize: import("./common/index.js").IModelAuthorizeSettings;
+            entry: IModelRegistryEntry;
+        }[];
+        getAuthorizeModelSettings(opts: {
+            format: "record";
+        }): Record<string, {
+            authorize: import("./common/index.js").IModelAuthorizeSettings;
+            entry: IModelRegistryEntry;
+        }>;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+    };
+} & {
+    new (...args: any[]): {
+        setDataSourceMetadata<Target extends object = object>(opts: {
+            target: Target;
+            metadata?: import("./common/index.js").IDataSourceMetadata;
+        }): void;
+        getDataSourceMetadata<Target extends object = object>(opts: {
+            target: Target;
+        }): import("./common/index.js").IDataSourceMetadata | undefined;
+        define: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+            value: Value;
+        }) => void;
+        get: <Target extends object = object, Value = any>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => Value | undefined;
+        has: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        delete: <Target extends object = object>(opts: {
+            target: Target;
+            key: import("@venizia/ignis-inversion").TBindingKey;
+        }) => boolean;
+        getKeys: <Target extends object = object>(opts: {
+            target: Target;
+        }) => import("@venizia/ignis-inversion").TBindingKey[];
+        getMethodNames: <T = any>(opts: {
+            target: import("@venizia/ignis-inversion").TClass<T>;
+        }) => string[];
+        clearMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => void;
+        setPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+            metadata: import("@venizia/ignis-inversion").IPropertyMetadata;
+        }) => void;
+        getPropertiesMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => Map<string | symbol, import("@venizia/ignis-inversion").IPropertyMetadata> | undefined;
+        getPropertyMetadata: <T extends object = object>(opts: {
+            target: T;
+            propertyName: string | symbol;
+        }) => import("@venizia/ignis-inversion").IPropertyMetadata | undefined;
+        setInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+            index: number;
+            metadata: import("@venizia/ignis-inversion").IInjectMetadata;
+        }) => void;
+        getInjectMetadata: <T extends object = object>(opts: {
+            target: T;
+        }) => import("@venizia/ignis-inversion").IInjectMetadata[] | undefined;
+        scope: string;
+        identifier: string;
+    };
+} & typeof _MetadataRegistry;
+/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
+export declare class MetadataRegistry extends BaseRegistry {
+    static readonly SINGLETON_REAL_KEY = "metadata-registry";
+    private constructor();
+    static getInstance(): MetadataRegistry;
+    clearAll(): void;
+}
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/esm/helpers/inversion/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAEjF,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAU9E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAMjB,CAAC;AAEF,iHAAiH;AACjH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,MAAM,CAAC,QAAQ,CAAC,kBAAkB,uBAAuB;IAEzD,OAAO;IAOP,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAOtC,QAAQ,IAAI,IAAI;CAKjB"}

package/dist/esm/helpers/inversion/registry.js

@@ -0,0 +1,26 @@
+import { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
+import { SingletonRealm } from '../singleton-realm.js';
+import { ControllerMetadataMixin, DatasourceMetadataMixin, GrpcControllerMetadataMixin, ModelMetadataMixin, RepositoryMetadataMixin, RestControllerMetadataMixin, } from './mixins/index.js';
+const BaseRegistry = GrpcControllerMetadataMixin(RestControllerMetadataMixin(ControllerMetadataMixin(RepositoryMetadataMixin(ModelMetadataMixin(DatasourceMetadataMixin(_MetadataRegistry))))));
+/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
+export class MetadataRegistry extends BaseRegistry {
+    static { this.SINGLETON_REAL_KEY = 'metadata-registry'; }
+    constructor() {
+        super();
+        this.modelRegistry = new Map();
+        this.repositoryBindings = new Map();
+        this.datasourceModels = new Map();
+    }
+    static getInstance() {
+        return SingletonRealm.resolve({
+            key: MetadataRegistry.SINGLETON_REAL_KEY,
+            create: () => new MetadataRegistry(),
+        });
+    }
+    clearAll() {
+        this.modelRegistry.clear();
+        this.repositoryBindings.clear();
+        this.datasourceModels.clear();
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/esm/helpers/inversion/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,2BAA2B,EAC3B,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,UAAU,CAAC;AAElB,MAAM,YAAY,GAAG,2BAA2B,CAC9C,2BAA2B,CACzB,uBAAuB,CACrB,uBAAuB,CAAC,kBAAkB,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CACxF,CACF,CACF,CAAC;AAEF,iHAAiH;AACjH,MAAM,OAAO,gBAAiB,SAAQ,YAAY;aAChC,uBAAkB,GAAG,mBAAmB,CAAC;IAEzD;QACE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,EAA+B,CAAC;QAC5D,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAA8B,CAAC;QAChE,IAAI,CAAC,gBAAgB,GAAG,IAAI,GAAG,EAAgC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,OAAO,cAAc,CAAC,OAAO,CAAC;YAC5B,GAAG,EAAE,gBAAgB,CAAC,kBAAkB;YACxC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,gBAAgB,EAAE;SACrC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC"}

package/dist/esm/helpers/singleton-realm.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Anchors a value on the realm instead of on a module.
+ *
+ * Two copies of `@venizia/ignis-kernel` can end up in one install without either package changing:
+ * `@venizia/ignis` and `@venizia/ignis-connectors` each pin a range, and the day those ranges stop
+ * intersecting a package manager installs a nested second copy rather than failing. Module-level
+ * statics then split in two, and nothing throws - `@repository` writes into one `datasourceModels`
+ * map while `discoverSchema()` reads the other, `buildSchema()` returns `{}`, and every query fails
+ * for a reason that points nowhere near the cause.
+ *
+ * `Symbol.for` is keyed on a global registry per realm, so both copies resolve the same symbol and
+ * therefore the same instance. A browser tab and its Worker are separate realms and still get one
+ * registry each, which is correct - they run separate applications.
+ */
+export declare class SingletonRealm {
+    private static readonly ANCHOR_PREFIX;
+    /**
+     * Anchors are memoized, not the values: an anchored value is created once and only ever mutated,
+     * so re-deriving its symbol per call buys nothing. The audit enrichers reach this twice per
+     * inserted row.
+     */
+    private static readonly anchors;
+    /** The realm's own singleton for `key`, created on first call and shared by every copy of this package. */
+    static resolve<T>(opts: {
+        key: string;
+        create: () => T;
+    }): T;
+    private static anchorFor;
+}
+//# sourceMappingURL=singleton-realm.d.ts.map

package/dist/esm/helpers/singleton-realm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton-realm.d.ts","sourceRoot":"","sources":["../../../src/helpers/singleton-realm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAA4B;IAEjE;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAE5D,2GAA2G;IAC3G,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,CAAC;IAkB5D,OAAO,CAAC,MAAM,CAAC,SAAS;CAazB"}

package/dist/esm/helpers/singleton-realm.js

@@ -0,0 +1,48 @@
+/**
+ * Anchors a value on the realm instead of on a module.
+ *
+ * Two copies of `@venizia/ignis-kernel` can end up in one install without either package changing:
+ * `@venizia/ignis` and `@venizia/ignis-connectors` each pin a range, and the day those ranges stop
+ * intersecting a package manager installs a nested second copy rather than failing. Module-level
+ * statics then split in two, and nothing throws - `@repository` writes into one `datasourceModels`
+ * map while `discoverSchema()` reads the other, `buildSchema()` returns `{}`, and every query fails
+ * for a reason that points nowhere near the cause.
+ *
+ * `Symbol.for` is keyed on a global registry per realm, so both copies resolve the same symbol and
+ * therefore the same instance. A browser tab and its Worker are separate realms and still get one
+ * registry each, which is correct - they run separate applications.
+ */
+export class SingletonRealm {
+    static { this.ANCHOR_PREFIX = '@venizia/ignis-kernel:'; }
+    /**
+     * Anchors are memoized, not the values: an anchored value is created once and only ever mutated,
+     * so re-deriving its symbol per call buys nothing. The audit enrichers reach this twice per
+     * inserted row.
+     */
+    static { this.anchors = new Map(); }
+    /** The realm's own singleton for `key`, created on first call and shared by every copy of this package. */
+    static resolve(opts) {
+        const { key, create } = opts;
+        const anchor = this.anchorFor({ key });
+        const realm = globalThis;
+        // `in`, not a truthiness check: a holder whose only field is still `undefined` is a legitimate
+        // resolved value, and re-creating it would hand every caller a fresh slot.
+        if (anchor in realm) {
+            return realm[anchor];
+        }
+        const created = create();
+        realm[anchor] = created;
+        return created;
+    }
+    static anchorFor(opts) {
+        const { key } = opts;
+        const cached = this.anchors.get(key);
+        if (cached) {
+            return cached;
+        }
+        const anchor = Symbol.for(`${this.ANCHOR_PREFIX}${key}`);
+        this.anchors.set(key, anchor);
+        return anchor;
+    }
+}
+//# sourceMappingURL=singleton-realm.js.map

package/dist/esm/helpers/singleton-realm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton-realm.js","sourceRoot":"","sources":["../../../src/helpers/singleton-realm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,cAAc;aACD,kBAAa,GAAG,wBAAwB,CAAC;IAEjE;;;;OAIG;aACqB,YAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE5D,2GAA2G;IAC3G,MAAM,CAAC,OAAO,CAAI,IAAsC;QACtD,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAE7B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QACvC,MAAM,KAAK,GAAG,UAA0C,CAAC;QAEzD,+FAA+F;QAC/F,2EAA2E;QAC3E,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;QACzB,KAAK,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;QAExB,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,MAAM,CAAC,SAAS,CAAC,IAAqB;QAC5C,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QAErB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,GAAG,GAAG,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAE9B,OAAO,MAAM,CAAC;IAChB,CAAC"}

package/dist/esm/index.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export * from './base/index.js';
+export * from './common/index.js';
+export * from './helpers/index.js';
+export * from './utilities/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export * from './base/index.js';
+export * from './common/index.js';
+export * from './helpers/index.js';
+export * from './utilities/index.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/esm/utilities/error.utility.d.ts

@@ -0,0 +1,8 @@
+import type { ILogger } from '@venizia/ignis-helpers/core';
+/** Standardized NotSupported error (HTTP 501) for a capability an implementation deliberately does not provide - logs a warning before throwing so the gap shows in operational logs, not just to the caller. */
+export declare const throwNotSupported: (opts: {
+    scope: string;
+    feature: string;
+    logger: ILogger;
+}) => never;
+//# sourceMappingURL=error.utility.d.ts.map

package/dist/esm/utilities/error.utility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.utility.d.ts","sourceRoot":"","sources":["../../../src/utilities/error.utility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAI3D,iNAAiN;AACjN,eAAO,MAAM,iBAAiB,GAAI,MAAM;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;CACjB,KAAG,KAUH,CAAC"}

package/dist/esm/utilities/error.utility.js

@@ -0,0 +1,14 @@
+import { CoreErrorCodes } from '../common/index.js';
+import { getError } from '@venizia/ignis-helpers/core';
+import { HTTP } from '@venizia/ignis-helpers/common';
+/** Standardized NotSupported error (HTTP 501) for a capability an implementation deliberately does not provide - logs a warning before throwing so the gap shows in operational logs, not just to the caller. */
+export const throwNotSupported = (opts) => {
+    const { scope, feature, logger } = opts;
+    logger.for(throwNotSupported.name).warn('%s is not supported | Scope: %s', feature, scope);
+    throw getError({
+        statusCode: HTTP.ResultCodes.RS_5.NotImplemented,
+        messageCode: CoreErrorCodes.NOT_SUPPORTED,
+        message: `[${scope}] ${feature} is not supported.`,
+    });
+};
+//# sourceMappingURL=error.utility.js.map

package/dist/esm/utilities/error.utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.utility.js","sourceRoot":"","sources":["../../../src/utilities/error.utility.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAErD,iNAAiN;AACjN,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAIjC,EAAS,EAAE;IACV,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAExC,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,iCAAiC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAE3F,MAAM,QAAQ,CAAC;QACb,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc;QAChD,WAAW,EAAE,cAAc,CAAC,aAAa;QACzC,OAAO,EAAE,IAAI,KAAK,KAAK,OAAO,oBAAoB;KACnD,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/esm/utilities/index.d.ts

@@ -0,0 +1,4 @@
+export * from './error.utility.js';
+export * from './jsx.utility.js';
+export * from './schema.utility.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/utilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/esm/utilities/index.js

@@ -0,0 +1,4 @@
+export * from './error.utility.js';
+export * from './jsx.utility.js';
+export * from './schema.utility.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/utilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utilities/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}