@mahmoud-auth/model-climbers 0.0.0-stage → 0.1.0

package/dist/resource-cascade/base/repository-registry.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeRepositoryRegistry = void 0;
+class CascadeRepositoryRegistry {
+    repositories;
+    constructor(repositories) {
+        this.repositories = repositories;
+    }
+    get(type) {
+        return this.repositories.get(type);
+    }
+}
+exports.CascadeRepositoryRegistry = CascadeRepositoryRegistry;

package/dist/resource-cascade/compiler.d.ts

@@ -0,0 +1,9 @@
+import { ResourceCascadeRegistry } from "./registry";
+import { ResourceCascadeScanner } from "./scanner";
+import { ResourceFieldCompiler } from "../base-resource-field/compiler";
+export declare class ResourceCascadeCompiler extends ResourceFieldCompiler {
+    private readonly cascadeScanner;
+    private readonly cascadeRegistry;
+    constructor(cascadeScanner: ResourceCascadeScanner, cascadeRegistry: ResourceCascadeRegistry);
+    compileCascades(): void;
+}

package/dist/resource-cascade/compiler.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCascadeCompiler = void 0;
+const common_1 = require("@nestjs/common");
+const registry_1 = require("./registry");
+const scanner_1 = require("./scanner");
+const compiler_1 = require("../base-resource-field/compiler");
+let ResourceCascadeCompiler = class ResourceCascadeCompiler extends compiler_1.ResourceFieldCompiler {
+    cascadeScanner;
+    cascadeRegistry;
+    constructor(cascadeScanner, cascadeRegistry) {
+        super(cascadeScanner, cascadeRegistry);
+        this.cascadeScanner = cascadeScanner;
+        this.cascadeRegistry = cascadeRegistry;
+    }
+    compileCascades() {
+        super.compileFields();
+    }
+};
+exports.ResourceCascadeCompiler = ResourceCascadeCompiler;
+exports.ResourceCascadeCompiler = ResourceCascadeCompiler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [scanner_1.ResourceCascadeScanner,
+        registry_1.ResourceCascadeRegistry])
+], ResourceCascadeCompiler);

package/dist/resource-cascade/decorator.d.ts

@@ -0,0 +1,10 @@
+import { Type } from "@nestjs/common";
+import { CascadeType } from "./enum";
+export interface ResourceCascadeMetadata<K = unknown> {
+    propertyKey: string;
+    targetModel: () => Type<K>;
+    type: CascadeType;
+}
+export declare const RESOURCE_CASCADE_METADATA: unique symbol;
+export declare const getResourceCascadeModels: () => Type[];
+export declare const ResourceCascade: (targetModelFunction: () => Type, type: CascadeType) => PropertyDecorator;

package/dist/resource-cascade/decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCascade = exports.getResourceCascadeModels = exports.RESOURCE_CASCADE_METADATA = void 0;
+exports.RESOURCE_CASCADE_METADATA = Symbol('RESOURCE_CASCADE');
+const resourceCascadeModels = new Set();
+const getResourceCascadeModels = () => Array.from(resourceCascadeModels);
+exports.getResourceCascadeModels = getResourceCascadeModels;
+const ResourceCascade = (targetModelFunction, type) => (prototype, propertyKey) => {
+    resourceCascadeModels.add(prototype.constructor);
+    const existing = [
+        ...(Reflect.getOwnMetadata(exports.RESOURCE_CASCADE_METADATA, prototype.constructor) || []),
+    ];
+    existing.push({
+        propertyKey: propertyKey.toString(),
+        targetModel: targetModelFunction,
+        type
+    });
+    Reflect.defineMetadata(exports.RESOURCE_CASCADE_METADATA, existing, prototype.constructor);
+};
+exports.ResourceCascade = ResourceCascade;

package/dist/resource-cascade/enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum CascadeType {
+    NULL = "null",
+    DELETE = "delete"
+}

package/dist/resource-cascade/enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeType = void 0;
+var CascadeType;
+(function (CascadeType) {
+    CascadeType["NULL"] = "null";
+    CascadeType["DELETE"] = "delete";
+})(CascadeType || (exports.CascadeType = CascadeType = {}));

package/dist/resource-cascade/index.d.ts

@@ -0,0 +1,9 @@
+export * from './decorator';
+export * from './enum';
+export * from './type';
+export * from './module';
+export * from './registry';
+export * from './base/base-model';
+export * from './base/base-cascade-helper.repository';
+export * from './base/base-service';
+export * from './token';

package/dist/resource-cascade/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./type"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./registry"), exports);
+__exportStar(require("./base/base-model"), exports);
+__exportStar(require("./base/base-cascade-helper.repository"), exports);
+__exportStar(require("./base/base-service"), exports);
+__exportStar(require("./token"), exports);

package/dist/resource-cascade/module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule, OnModuleInit, Type } from '@nestjs/common';
+import { ModelDefinition } from '@nestjs/mongoose';
+import { ResourceCascadeCompiler } from './compiler';
+export interface CascadeModelDefinition<T = unknown> extends ModelDefinition {
+    type: Type<T>;
+}
+export declare class ResourceCascadeModule implements OnModuleInit {
+    private readonly resourceCascadeCompiler?;
+    constructor(resourceCascadeCompiler?: ResourceCascadeCompiler | undefined);
+    onModuleInit(): void;
+    static forRoot(resources: CascadeModelDefinition[], connectionName?: string): DynamicModule;
+    static forFeature<T>(...resources: Type<T>[]): DynamicModule;
+}

package/dist/resource-cascade/module.js

@@ -0,0 +1,102 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ResourceCascadeModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCascadeModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const mongoose_1 = require("@nestjs/mongoose");
+const utils_1 = require("@mahmoud-auth/utils");
+const base_model_1 = require("./base/base-model");
+const base_service_1 = require("./base/base-service");
+const repository_registry_1 = require("./base/repository-registry");
+const compiler_1 = require("./compiler");
+const mongo_cascade_helper_repository_1 = require("./mongo/mongo-cascade-helper.repository");
+const registry_1 = require("./registry");
+const scanner_1 = require("./scanner");
+const token_1 = require("./token");
+let ResourceCascadeModule = ResourceCascadeModule_1 = class ResourceCascadeModule {
+    resourceCascadeCompiler;
+    constructor(resourceCascadeCompiler) {
+        this.resourceCascadeCompiler = resourceCascadeCompiler;
+    }
+    onModuleInit() {
+        this.resourceCascadeCompiler?.compileCascades();
+    }
+    static forRoot(resources, connectionName) {
+        if (resources.length === 0) {
+            throw new Error('ResourceCascadeModule.forRoot requires at least one model');
+        }
+        const resourceTypes = new Set(resources.map(({ type }) => type));
+        if (resourceTypes.size !== resources.length) {
+            throw new Error('ResourceCascadeModule.forRoot cannot register the same resource type more than once');
+        }
+        const resourceTypeNames = new Set(resources.map(({ type }) => type.name));
+        if (resourceTypeNames.size !== resources.length) {
+            throw new Error('ResourceCascadeModule.forRoot requires unique resource class names');
+        }
+        const modelNames = new Set(resources.map(({ name }) => name));
+        if (modelNames.size !== resources.length) {
+            throw new Error('ResourceCascadeModule.forRoot cannot register the same Mongoose model name more than once');
+        }
+        const modelTokens = resources.map(({ name }) => (0, mongoose_1.getModelToken)(name, connectionName));
+        const cascadeModelTokens = resources.map(({ type }) => (0, token_1.getCascadeMongooseModelToken)(type));
+        const modelAliases = resources.map(({ type }, index) => (0, utils_1.useFactory)(cascadeModelTokens[index], (model) => model, { inject: [modelTokens[index]] }));
+        return {
+            module: ResourceCascadeModule_1,
+            global: true,
+            imports: [
+                core_1.DiscoveryModule,
+                mongoose_1.MongooseModule.forFeature(resources.map(({ type: _type, ...definition }) => definition), connectionName),
+            ],
+            providers: [
+                (0, utils_1.useValue)(registry_1.ResourceCascadeRegistry, new registry_1.ResourceCascadeRegistry()),
+                scanner_1.ResourceCascadeScanner,
+                compiler_1.ResourceCascadeCompiler,
+                (0, utils_1.useFactory)(repository_registry_1.CascadeRepositoryRegistry, (...models) => {
+                    const repositories = models.map(model => new mongo_cascade_helper_repository_1.MongoCascadeHelperRepository(model));
+                    return new repository_registry_1.CascadeRepositoryRegistry((0, utils_1.getClassInstanceMapByKey)(repositories, (_repository, index) => resources[index].type));
+                }, { inject: modelTokens }),
+                (0, utils_1.useFactory)(base_service_1.CascadeService, (registry, repositories) => new base_service_1.CascadeService(registry, repositories), { inject: [registry_1.ResourceCascadeRegistry, repository_registry_1.CascadeRepositoryRegistry] }),
+                ...modelAliases,
+            ],
+            exports: [
+                base_service_1.CascadeService,
+                registry_1.ResourceCascadeRegistry,
+                repository_registry_1.CascadeRepositoryRegistry,
+                ...cascadeModelTokens,
+            ],
+        };
+    }
+    static forFeature(...resources) {
+        if (resources.length === 0) {
+            throw new Error('ResourceCascadeModule.forFeature requires at least one resource type');
+        }
+        if (new Set(resources).size !== resources.length) {
+            throw new Error('ResourceCascadeModule.forFeature cannot register the same resource type more than once');
+        }
+        const cascadeModelTokens = resources.map(resource => (0, token_1.getCascadeModelToken)(resource.name));
+        return {
+            module: ResourceCascadeModule_1,
+            providers: resources.map((type, index) => (0, utils_1.useFactory)(cascadeModelTokens[index], (model, cascadeService) => new base_model_1.CascadeModel(model, cascadeService, type), { inject: [(0, token_1.getCascadeMongooseModelToken)(type), base_service_1.CascadeService] })),
+            exports: cascadeModelTokens,
+        };
+    }
+};
+exports.ResourceCascadeModule = ResourceCascadeModule;
+exports.ResourceCascadeModule = ResourceCascadeModule = ResourceCascadeModule_1 = __decorate([
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [compiler_1.ResourceCascadeCompiler])
+], ResourceCascadeModule);

package/dist/resource-cascade/mongo/mongo-cascade-helper.repository.d.ts

@@ -0,0 +1,13 @@
+import { Model, RootFilterQuery } from "mongoose";
+import { CascadeDeleteOptions } from '../base/base-cascade-helper.repository';
+import { ICascadeHelperRepository } from "../base/base-cascade-helper.repository";
+export declare class MongoCascadeHelperRepository<T> implements ICascadeHelperRepository<T> {
+    private readonly model;
+    constructor(model: Model<T>);
+    getIdKey(id: unknown): string;
+    findIds(filter: RootFilterQuery<T>, options?: CascadeDeleteOptions): Promise<unknown[]>;
+    findIdsByField(field: string, value: unknown, options?: CascadeDeleteOptions): Promise<unknown[]>;
+    findIdByField(field: string, value: unknown): Promise<unknown>;
+    nullifyByField(field: string, value: unknown, options?: CascadeDeleteOptions): Promise<void>;
+    deleteById(id: unknown, options?: CascadeDeleteOptions): Promise<unknown | null>;
+}

package/dist/resource-cascade/mongo/mongo-cascade-helper.repository.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoCascadeHelperRepository = void 0;
+class MongoCascadeHelperRepository {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    getIdKey(id) {
+        if (id && typeof id === 'object' && 'toHexString' in id && typeof id.toHexString === 'function') {
+            return id.toHexString();
+        }
+        return String(id);
+    }
+    async findIds(filter, options) {
+        const query = options
+            ? this.model.find(filter, { _id: 1 }, options)
+            : this.model.find(filter, { _id: 1 });
+        const documents = await query.lean();
+        return documents.map(({ _id }) => _id);
+    }
+    async findIdsByField(field, value, options) {
+        const filter = { [field]: value };
+        const query = options
+            ? this.model.find(filter, { _id: 1 }, options)
+            : this.model.find(filter, { _id: 1 });
+        const documents = await query.lean();
+        return documents.map(({ _id }) => _id);
+    }
+    async findIdByField(field, value) {
+        const document = await this.model.findOne({ [field]: value }, { _id: 1 }).lean();
+        return document?._id;
+    }
+    async nullifyByField(field, value, options) {
+        const filter = { [field]: value };
+        const update = { $set: { [field]: null } };
+        if (options) {
+            await this.model.updateMany(filter, update, options);
+            return;
+        }
+        await this.model.updateMany(filter, update);
+    }
+    async deleteById(id, options) {
+        if (options) {
+            return this.model.findByIdAndDelete(id, options);
+        }
+        return this.model.findByIdAndDelete(id);
+    }
+}
+exports.MongoCascadeHelperRepository = MongoCascadeHelperRepository;

package/dist/resource-cascade/registry.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@nestjs/common';
+import { ResourceFieldRegistry } from '../base-resource-field';
+import { IResourceCascade } from './type';
+export declare class ResourceCascadeRegistry extends ResourceFieldRegistry {
+    constructor();
+    register<T, K>(resourceCascade: IResourceCascade<T, K>): void;
+    getReferencing<T>(targetModel: Type<T>): IResourceCascade<unknown, T>[];
+}

package/dist/resource-cascade/registry.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCascadeRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const base_resource_field_1 = require("../base-resource-field");
+let ResourceCascadeRegistry = class ResourceCascadeRegistry extends base_resource_field_1.ResourceFieldRegistry {
+    constructor() {
+        super(new Map());
+    }
+    register(resourceCascade) {
+        super.register(resourceCascade);
+    }
+    getReferencing(targetModel) {
+        return Array.from(this.entries.values())
+            .flat()
+            .filter(cascade => cascade.targetModel === targetModel);
+    }
+};
+exports.ResourceCascadeRegistry = ResourceCascadeRegistry;
+exports.ResourceCascadeRegistry = ResourceCascadeRegistry = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], ResourceCascadeRegistry);

package/dist/resource-cascade/scanner.d.ts

@@ -0,0 +1,10 @@
+import { Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { ResourceFieldScanner } from '../base-resource-field';
+import { IResourceCascade } from './type';
+export declare class ResourceCascadeScanner extends ResourceFieldScanner {
+    private readonly reflector;
+    constructor(reflector: Reflector);
+    lookupFields(): IResourceCascade<unknown, unknown>[];
+    protected getMetadata<T>(target: Type<T>): IResourceCascade<T, unknown>[];
+}

package/dist/resource-cascade/scanner.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCascadeScanner = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const base_resource_field_1 = require("../base-resource-field");
+const decorator_1 = require("./decorator");
+let ResourceCascadeScanner = class ResourceCascadeScanner extends base_resource_field_1.ResourceFieldScanner {
+    reflector;
+    constructor(reflector) {
+        super((0, decorator_1.getResourceCascadeModels)());
+        this.reflector = reflector;
+    }
+    lookupFields() {
+        return super.lookupFields();
+    }
+    getMetadata(target) {
+        const cascades = this.reflector.get(decorator_1.RESOURCE_CASCADE_METADATA, target);
+        if (!cascades) {
+            return [];
+        }
+        return cascades.map(({ targetModel, propertyKey, type }) => ({
+            sourceModel: target,
+            targetModel: targetModel(),
+            propertyKey,
+            type
+        }));
+    }
+};
+exports.ResourceCascadeScanner = ResourceCascadeScanner;
+exports.ResourceCascadeScanner = ResourceCascadeScanner = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector])
+], ResourceCascadeScanner);

package/dist/resource-cascade/token.d.ts

@@ -0,0 +1,4 @@
+import { Type } from "@nestjs/common";
+export declare const getCascadeModelToken: (name: string) => string;
+export declare const InjectCascadeModel: (name: string) => PropertyDecorator & ParameterDecorator;
+export declare const getCascadeMongooseModelToken: (type: Type) => string;

package/dist/resource-cascade/token.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCascadeMongooseModelToken = exports.InjectCascadeModel = exports.getCascadeModelToken = void 0;
+const common_1 = require("@nestjs/common");
+const getCascadeModelToken = (name) => `CASCADE_MODEL(${name})`;
+exports.getCascadeModelToken = getCascadeModelToken;
+const InjectCascadeModel = (name) => (0, common_1.Inject)((0, exports.getCascadeModelToken)(name));
+exports.InjectCascadeModel = InjectCascadeModel;
+const getCascadeMongooseModelToken = (type) => `CASCADE_MONGOOSE_MODEL(${type.name})`;
+exports.getCascadeMongooseModelToken = getCascadeMongooseModelToken;

package/dist/resource-cascade/type.d.ts

@@ -0,0 +1,8 @@
+import { Type } from "@nestjs/common";
+import { CascadeType } from "./enum";
+export interface IResourceCascade<T, K> {
+    sourceModel: Type<T>;
+    targetModel: Type<K>;
+    propertyKey: string;
+    type: CascadeType;
+}

package/dist/resource-cascade/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/transition/compiler.d.ts

@@ -0,0 +1,8 @@
+import { TransitionScanner } from "./scanner";
+import { TransitionRegistry } from "./registry";
+export declare class TransitionCompiler {
+    private readonly scanner;
+    private readonly registry;
+    constructor(scanner: TransitionScanner, registry: TransitionRegistry);
+    compileTransitions(): void;
+}

package/dist/transition/compiler.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionCompiler = void 0;
+const common_1 = require("@nestjs/common");
+const scanner_1 = require("./scanner");
+const registry_1 = require("./registry");
+let TransitionCompiler = class TransitionCompiler {
+    scanner;
+    registry;
+    constructor(scanner, registry) {
+        this.scanner = scanner;
+        this.registry = registry;
+    }
+    compileTransitions() {
+        this.scanner
+            .lookupTransitions()
+            .forEach(transition => this.registry.registryEntry(transition));
+        this.registry.freeze();
+    }
+};
+exports.TransitionCompiler = TransitionCompiler;
+exports.TransitionCompiler = TransitionCompiler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [scanner_1.TransitionScanner,
+        registry_1.TransitionRegistry])
+], TransitionCompiler);

package/dist/transition/decorator.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '@nestjs/common';
+export declare const TRANSITION_METADATA: unique symbol;
+export declare function Transition<T, K>(from: Type<T>, to: Type<K>): import("@nestjs/common").CustomDecorator<typeof TRANSITION_METADATA>;

package/dist/transition/decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSITION_METADATA = void 0;
+exports.Transition = Transition;
+const common_1 = require("@nestjs/common");
+exports.TRANSITION_METADATA = Symbol('TRANSITION');
+function Transition(from, to) {
+    return (0, common_1.SetMetadata)(exports.TRANSITION_METADATA, {
+        from,
+        to
+    });
+}

package/dist/transition/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+export * from './module';

package/dist/transition/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./registry"), exports);
+__exportStar(require("./module"), exports);

package/dist/transition/module.d.ts

@@ -0,0 +1,7 @@
+import { OnModuleInit } from "@nestjs/common";
+import { TransitionCompiler } from "./compiler";
+export declare class TransitionModule implements OnModuleInit {
+    private readonly transitionCompiler;
+    constructor(transitionCompiler: TransitionCompiler);
+    onModuleInit(): void;
+}

package/dist/transition/module.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const compiler_1 = require("./compiler");
+const registry_1 = require("./registry");
+const scanner_1 = require("./scanner");
+let TransitionModule = class TransitionModule {
+    transitionCompiler;
+    constructor(transitionCompiler) {
+        this.transitionCompiler = transitionCompiler;
+    }
+    onModuleInit() {
+        this.transitionCompiler.compileTransitions();
+    }
+};
+exports.TransitionModule = TransitionModule;
+exports.TransitionModule = TransitionModule = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.DiscoveryModule],
+        providers: [registry_1.TransitionRegistry, scanner_1.TransitionScanner, compiler_1.TransitionCompiler],
+        exports: [registry_1.TransitionRegistry]
+    }),
+    __metadata("design:paramtypes", [compiler_1.TransitionCompiler])
+], TransitionModule);

package/dist/transition/registry.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@nestjs/common';
+import { BaseMahmoudRegistry } from '@mahmoud-auth/base-registry';
+import { ResourceTransition } from './type';
+export declare class TransitionRegistry extends BaseMahmoudRegistry<string, ResourceTransition<any, any>> {
+    constructor();
+    registryEntry<T, K>(transition: ResourceTransition<T, K>): void;
+    get<From, To>(from: Type, to: Type): ResourceTransition<From, To> | undefined;
+}

package/dist/transition/registry.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const base_registry_1 = require("@mahmoud-auth/base-registry");
+const key = (from, to) => {
+    return `${from.name}->${to.name}`;
+};
+let TransitionRegistry = class TransitionRegistry extends base_registry_1.BaseMahmoudRegistry {
+    constructor() {
+        super(new Map());
+    }
+    registryEntry(transition) {
+        this.checkIsFrozen(this.constructor.name);
+        this.entries.set(key(transition.from, transition.to), transition);
+    }
+    get(from, to) {
+        return this.entries.get(key(from, to));
+    }
+};
+exports.TransitionRegistry = TransitionRegistry;
+exports.TransitionRegistry = TransitionRegistry = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], TransitionRegistry);