@venizia/ignis 0.1.1 → 0.2.0-0

package/dist/helpers/inversion/mixins/repository.mixin.js

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RepositoryMetadataMixin = void 0;
-const relation_1 = require("../../../connectors/relational/repositories/dialect/relation");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-const keys_1 = require("../common/keys");
-const RepositoryMetadataMixin = (baseClass) => {
-    return class extends baseClass {
-        setRepositoryMetadata(opts) {
-            const { target, metadata } = opts;
-            Reflect.defineMetadata(keys_1.MetadataKeys.REPOSITORY, metadata, target);
-        }
-        getRepositoryMetadata(opts) {
-            const { target } = opts;
-            return Reflect.getMetadata(keys_1.MetadataKeys.REPOSITORY, target);
-        }
-        /** Registers a repository binding (called by @repository) linking a repository to its model + datasource. */
-        registerRepositoryBinding(opts) {
-            // Every member of the binding may be a resolver, the escape hatch for circular imports.
-            // Reading `.name` off the resolver keys the registry by the arrow's inferred name, and the
-            // datasource then silently discovers no schema.
-            const repositoryClass = (0, ignis_helpers_1.resolveValue)(opts.repository);
-            this.repositoryBindings.set(repositoryClass.name, opts);
-            const dataSourceRef = (0, ignis_helpers_1.resolveValue)(opts.dataSource);
-            const dsKey = typeof dataSourceRef === 'string' ? dataSourceRef : dataSourceRef.name;
-            const modelClass = (0, ignis_helpers_1.resolveValue)(opts.model);
-            if (!this.datasourceModels.has(dsKey)) {
-                this.datasourceModels.set(dsKey, new Set());
-            }
-            this.datasourceModels.get(dsKey).add(modelClass);
-        }
-        getRepositoryBinding(opts) {
-            return this.repositoryBindings.get(opts.name);
-        }
-        /**
-         * Resolves and caches relations for a model entry - called lazily from buildSchema() so that
-         * every `@model` class is registered first, which avoids circular-dependency ordering issues.
-         * @internal
-         */
-        resolveModelRelations(modelMeta) {
-            if (modelMeta._builtRelations !== undefined) {
-                return modelMeta._builtRelations;
-            }
-            if (!modelMeta.relationsResolver) {
-                return undefined;
-            }
-            const relations = (0, ignis_helpers_1.resolveValue)(modelMeta.relationsResolver);
-            if (relations && modelMeta.schema) {
-                // The registry stores schema as unknown (engine-neutral); this resolver only runs for
-                // drizzle-backed models, so the narrow is safe.
-                const builtRelations = (0, relation_1.createRelations)({
-                    source: modelMeta.schema,
-                    relations,
-                });
-                modelMeta._builtRelations = builtRelations?.relations;
-                return modelMeta._builtRelations;
-            }
-            return undefined;
-        }
-        /**
-         * Models registered for a datasource, relations resolved lazily. `schema`/`relations` stay
-         * `unknown` - the registry is shared across connectors, so each connector narrows at its call
-         * site.
-         */
-        getModels(opts) {
-            const { dataSource } = opts;
-            const dsKey = typeof dataSource === 'string' ? dataSource : dataSource.name;
-            const modelClasses = this.datasourceModels.get(dsKey) ?? new Set();
-            const rs = Array.from(modelClasses)
-                .map(modelClass => {
-                // Read straight off the class: a class -> name -> modelRegistry round-trip collapses two
-                // same-named models onto one entry, silently swapping schemas. `modelRegistry` stays
-                // name-keyed for the by-name APIs that need it.
-                const entry = {
-                    target: modelClass,
-                    metadata: this.getModelMetadata({ target: modelClass }) ?? { settings: {} },
-                    schema: modelClass.schema,
-                    relationsResolver: modelClass.relations,
-                };
-                if (entry.schema === undefined) {
-                    return null;
-                }
-                return {
-                    tableName: this.resolveModelKey({ modelClass }),
-                    schema: entry.schema,
-                    relations: this.resolveModelRelations(entry),
-                };
-            })
-                .filter((item) => {
-                return item !== undefined && item !== null;
-            });
-            return rs;
-        }
-        /**
-         * Like getModels but returns only resolved model classes - used by BaseSearchDataSource, which
-         * has no pgTable to resolve.
-         */
-        getModelClasses(opts) {
-            const { dataSource } = opts;
-            const dsKey = typeof dataSource === 'string' ? dataSource : dataSource.name;
-            // Straight from the stored class refs: a name round-trip through the shared modelRegistry
-            // would hand back whichever same-named class registered last.
-            return Array.from(this.datasourceModels.get(dsKey) ?? new Set());
-        }
-        /** The key a model occupies in `modelRegistry` - its table name, or its class name when it has none. */
-        resolveModelKey(opts) {
-            const { modelClass } = opts;
-            const modelMetadata = this.getModelMetadata({ target: modelClass });
-            return ([modelMetadata?.tableName, modelClass.TABLE_NAME].find(Boolean) ??
-                modelClass.name);
-        }
-        /** Assembles table schemas + relations for a datasource's registered models. */
-        buildSchema(opts) {
-            const { dataSource } = opts;
-            const models = this.getModels({ dataSource });
-            const rs = { schema: {}, relations: {} };
-            for (const model of models) {
-                if (model.schema) {
-                    rs.schema[model.tableName] = model.schema;
-                }
-                if (model.relations) {
-                    rs.relations[`${model.tableName}Relations`] = model.relations;
-                }
-            }
-            return rs;
-        }
-        hasModels(opts) {
-            const dsKey = typeof opts.dataSource === 'string' ? opts.dataSource : opts.dataSource.name;
-            const modelNames = this.datasourceModels.get(dsKey);
-            return modelNames !== undefined && modelNames.size > 0;
-        }
-    };
-};
-exports.RepositoryMetadataMixin = RepositoryMetadataMixin;
-//# sourceMappingURL=repository.mixin.js.map

package/dist/helpers/inversion/mixins/repository.mixin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"repository.mixin.js","sourceRoot":"","sources":["../../../../src/helpers/inversion/mixins/repository.mixin.ts"],"names":[],"mappings":"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"}

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

@@ -1,449 +0,0 @@
-import type { AnyType, TClass } from '@venizia/ignis-helpers';
-import { MetadataRegistry as _MetadataRegistry } from '@venizia/ignis-inversion';
-import type { IModelRegistryEntry, IRepositoryBinding } from './common/types';
-declare const BaseRegistry: {
-    new (...args: any[]): {
-        addRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("./common/types").IRpcMetadata;
-        }): void;
-        getRpcs<Target extends object = object>(opts: {
-            target: Target;
-        }): Map<string | symbol, import("./common/types").IRpcMetadata> | undefined;
-        getRpc<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("./common/types").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("../..").IAuthRouteConfig> | undefined;
-        getRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-        }): import("../..").IAuthRouteConfig | undefined;
-        hasRoutes<Target extends object = object>(opts: {
-            target: Target;
-        }): boolean;
-        addRoute<Target extends object = object>(opts: {
-            target: Target;
-            methodName: string | symbol;
-            configs: import("../..").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/types").TControllerMetadata;
-        }): void;
-        getControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").TControllerMetadata | undefined;
-        getRestControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IRestControllerMetadata | undefined;
-        getGrpcControllerMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").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("../..").AbstractEntity>>;
-        datasourceModels: Map<string, Set<TClass<AnyType>>>;
-        setRepositoryMetadata<Target extends object = object, Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: {
-            target: Target;
-            metadata: import("./common/types").IRepositoryMetadata<Model, DataSource>;
-        }): void;
-        getRepositoryMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): (import("./common/types").IRepositoryMetadata<import("../..").AbstractEntity<unknown>, import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>> & {
-            _resolved?: import("./common/types").IResolvedRepositoryMetadata;
-        }) | undefined;
-        registerRepositoryBinding<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>, DataSource extends import("../..").IDataSource = import("../..").IDataSource<{}, import("../..").TAnyDataSourceSchema, {}>>(opts: IRepositoryBinding<Model, DataSource>): void;
-        getRepositoryBinding(opts: {
-            name: string;
-        }): IRepositoryBinding<import("../..").AbstractEntity> | undefined;
-        resolveModelRelations(modelMeta: IModelRegistryEntry): unknown;
-        getModels(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            tableName: string;
-            schema: unknown;
-            relations?: unknown;
-        }[];
-        getModelClasses(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): Array<TClass<unknown>>;
-        resolveModelKey(opts: {
-            modelClass: TClass<AnyType>;
-        }): string;
-        buildSchema(opts: {
-            dataSource: string | TClass<import("../..").IDataSource>;
-        }): {
-            schema: Record<string, unknown>;
-            relations: Record<string, unknown>;
-        };
-        hasModels(opts: {
-            dataSource: string | TClass<import("../..").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/types").IModelMetadata | undefined;
-    };
-} & {
-    new (...args: any[]): {
-        modelRegistry: Map<string, IModelRegistryEntry>;
-        setModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").IModelMetadata | undefined;
-        registerModel<Model extends import("../..").AbstractEntity = import("../..").AbstractEntity<unknown>>(opts: {
-            target: import("./common/types").TDecoratorModelTarget<Model>;
-            metadata: import("./common/types").IModelMetadata;
-        }): void;
-        getModelEntry(opts: {
-            name: string;
-        }): IModelRegistryEntry | undefined;
-        getAllModels(): Map<string, IModelRegistryEntry>;
-        getModelAuthorizeSettings(opts: {
-            name: string;
-        }): import("./common/types").IModelAuthorizeSettings | undefined;
-        getAuthorizeModelPrincipals(opts: {
-            format: "array";
-        }): string[];
-        getAuthorizeModelPrincipals(opts: {
-            format: "record";
-        }): Record<string, string>;
-        getAuthorizeModelSettings(opts: {
-            format: "array";
-        }): {
-            name: string;
-            authorize: import("./common/types").IModelAuthorizeSettings;
-            entry: IModelRegistryEntry;
-        }[];
-        getAuthorizeModelSettings(opts: {
-            format: "record";
-        }): Record<string, {
-            authorize: import("./common/types").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/types").IDataSourceMetadata;
-        }): void;
-        getDataSourceMetadata<Target extends object = object>(opts: {
-            target: Target;
-        }): import("./common/types").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 {
-    private static instance;
-    private constructor();
-    static getInstance(): MetadataRegistry;
-    clearAll(): void;
-}
-export {};
-//# sourceMappingURL=registry.d.ts.map

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

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

package/dist/helpers/inversion/registry.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataRegistry = void 0;
-const ignis_inversion_1 = require("@venizia/ignis-inversion");
-const mixins_1 = require("./mixins");
-const BaseRegistry = (0, mixins_1.GrpcControllerMetadataMixin)((0, mixins_1.RestControllerMetadataMixin)((0, mixins_1.ControllerMetadataMixin)((0, mixins_1.RepositoryMetadataMixin)((0, mixins_1.ModelMetadataMixin)((0, mixins_1.DatasourceMetadataMixin)(ignis_inversion_1.MetadataRegistry))))));
-/** Central metadata registry: decorator metadata, the model registry, repository bindings and auto-discovery. */
-class MetadataRegistry extends BaseRegistry {
-    constructor() {
-        super();
-        this.modelRegistry = new Map();
-        this.repositoryBindings = new Map();
-        this.datasourceModels = new Map();
-    }
-    static getInstance() {
-        if (!MetadataRegistry.instance) {
-            MetadataRegistry.instance = new MetadataRegistry();
-        }
-        return MetadataRegistry.instance;
-    }
-    clearAll() {
-        this.modelRegistry.clear();
-        this.repositoryBindings.clear();
-        this.datasourceModels.clear();
-    }
-}
-exports.MetadataRegistry = MetadataRegistry;
-//# sourceMappingURL=registry.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/helpers/inversion/registry.ts"],"names":[],"mappings":";;;AACA,8DAAiF;AAEjF,qCAOkB;AAElB,MAAM,YAAY,GAAG,IAAA,oCAA2B,EAC9C,IAAA,oCAA2B,EACzB,IAAA,gCAAuB,EACrB,IAAA,gCAAuB,EAAC,IAAA,2BAAkB,EAAC,IAAA,gCAAuB,EAAC,kCAAiB,CAAC,CAAC,CAAC,CACxF,CACF,CACF,CAAC;AAEF,iHAAiH;AACjH,MAAa,gBAAiB,SAAQ,YAAY;IAGhD;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,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;YAC/B,gBAAgB,CAAC,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACrD,CAAC;QACD,OAAO,gBAAgB,CAAC,QAAQ,CAAC;IACnC,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;CACF;AAtBD,4CAsBC"}

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

@@ -1,8 +0,0 @@
-import type { ILogger } from '@venizia/ignis-helpers';
-/** 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/utilities/error.utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.utility.d.ts","sourceRoot":"","sources":["../../src/utilities/error.utility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGtD,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/utilities/error.utility.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwNotSupported = void 0;
-const common_1 = require("../common");
-const ignis_helpers_1 = require("@venizia/ignis-helpers");
-/** 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. */
-const throwNotSupported = (opts) => {
-    const { scope, feature, logger } = opts;
-    logger.for(exports.throwNotSupported.name).warn('%s is not supported | Scope: %s', feature, scope);
-    throw (0, ignis_helpers_1.getError)({
-        statusCode: ignis_helpers_1.HTTP.ResultCodes.RS_5.NotImplemented,
-        messageCode: common_1.CoreErrorCodes.NOT_SUPPORTED,
-        message: `[${scope}] ${feature} is not supported.`,
-    });
-};
-exports.throwNotSupported = throwNotSupported;
-//# sourceMappingURL=error.utility.js.map