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

package/dist/relations/resource-reference/compiler.d.ts

@@ -0,0 +1,9 @@
+import { ResourceReferenceRegistry } from "./registry";
+import { ResourceReferenceScanner } from "./scanner";
+import { ResourceFieldCompiler } from "../../base-resource-field";
+export declare class ResourceReferenceCompiler extends ResourceFieldCompiler {
+    private readonly referenceScanner;
+    private readonly referenceRegistry;
+    constructor(referenceScanner: ResourceReferenceScanner, referenceRegistry: ResourceReferenceRegistry);
+    compileReferences(): void;
+}

package/dist/relations/resource-reference/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.ResourceReferenceCompiler = void 0;
+const common_1 = require("@nestjs/common");
+const registry_1 = require("./registry");
+const scanner_1 = require("./scanner");
+const base_resource_field_1 = require("../../base-resource-field");
+let ResourceReferenceCompiler = class ResourceReferenceCompiler extends base_resource_field_1.ResourceFieldCompiler {
+    referenceScanner;
+    referenceRegistry;
+    constructor(referenceScanner, referenceRegistry) {
+        super(referenceScanner, referenceRegistry);
+        this.referenceScanner = referenceScanner;
+        this.referenceRegistry = referenceRegistry;
+    }
+    compileReferences() {
+        super.compileFields();
+    }
+};
+exports.ResourceReferenceCompiler = ResourceReferenceCompiler;
+exports.ResourceReferenceCompiler = ResourceReferenceCompiler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [scanner_1.ResourceReferenceScanner,
+        registry_1.ResourceReferenceRegistry])
+], ResourceReferenceCompiler);

package/dist/relations/resource-reference/decorator.d.ts

@@ -0,0 +1,7 @@
+import { Type } from "@nestjs/common";
+export interface ResourceReferenceMetadata<K = unknown> {
+    propertyKey: string;
+    targetModel: Type<K>;
+}
+export declare const RESOURCE_REFERENCE_METADATA: unique symbol;
+export declare const ResourceReference: (targetModelFunction: () => Type) => PropertyDecorator;

package/dist/relations/resource-reference/decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceReference = exports.RESOURCE_REFERENCE_METADATA = void 0;
+exports.RESOURCE_REFERENCE_METADATA = Symbol('RESOURCE_REFERENCE');
+const ResourceReference = (targetModelFunction) => (prototype, propertyKey) => {
+    const existing = Reflect.getMetadata(exports.RESOURCE_REFERENCE_METADATA, prototype.constructor) ?? [];
+    existing.push({ propertyKey: propertyKey.toString(), targetModel: targetModelFunction() });
+    Reflect.defineMetadata(exports.RESOURCE_REFERENCE_METADATA, existing, prototype.constructor);
+};
+exports.ResourceReference = ResourceReference;

package/dist/relations/resource-reference/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decorator';
+export * from './registry';
+export * from './type';
+export * from './module';

package/dist/relations/resource-reference/index.js

@@ -0,0 +1,20 @@
+"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("./registry"), exports);
+__exportStar(require("./type"), exports);
+__exportStar(require("./module"), exports);

package/dist/relations/resource-reference/module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule, OnModuleInit, Type } from "@nestjs/common";
+import { ResourceReferenceCompiler } from "./compiler";
+export declare class ResourceReferenceModule implements OnModuleInit {
+    private readonly resourceReferenceCompiler;
+    constructor(resourceReferenceCompiler: ResourceReferenceCompiler);
+    static forRoot(...resources: Type[]): DynamicModule;
+    onModuleInit(): void;
+}

package/dist/relations/resource-reference/module.js

@@ -0,0 +1,46 @@
+"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 ResourceReferenceModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceReferenceModule = 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");
+const resource_1 = require("../../resource");
+let ResourceReferenceModule = ResourceReferenceModule_1 = class ResourceReferenceModule {
+    resourceReferenceCompiler;
+    constructor(resourceReferenceCompiler) {
+        this.resourceReferenceCompiler = resourceReferenceCompiler;
+    }
+    static forRoot(...resources) {
+        return {
+            module: ResourceReferenceModule_1,
+            imports: [core_1.DiscoveryModule],
+            providers: [
+                (0, resource_1.useValueMahmoudResources)(resources),
+                registry_1.ResourceReferenceRegistry,
+                scanner_1.ResourceReferenceScanner,
+                compiler_1.ResourceReferenceCompiler
+            ],
+            exports: [registry_1.ResourceReferenceRegistry],
+        };
+    }
+    onModuleInit() {
+        this.resourceReferenceCompiler.compileReferences();
+    }
+};
+exports.ResourceReferenceModule = ResourceReferenceModule;
+exports.ResourceReferenceModule = ResourceReferenceModule = ResourceReferenceModule_1 = __decorate([
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [compiler_1.ResourceReferenceCompiler])
+], ResourceReferenceModule);

package/dist/relations/resource-reference/registry.d.ts

@@ -0,0 +1,4 @@
+import { ResourceFieldRegistry } from '../../base-resource-field';
+export declare class ResourceReferenceRegistry extends ResourceFieldRegistry {
+    constructor();
+}

package/dist/relations/resource-reference/registry.js

@@ -0,0 +1,24 @@
+"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.ResourceReferenceRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const base_resource_field_1 = require("../../base-resource-field");
+let ResourceReferenceRegistry = class ResourceReferenceRegistry extends base_resource_field_1.ResourceFieldRegistry {
+    constructor() {
+        super(new Map());
+    }
+};
+exports.ResourceReferenceRegistry = ResourceReferenceRegistry;
+exports.ResourceReferenceRegistry = ResourceReferenceRegistry = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], ResourceReferenceRegistry);

package/dist/relations/resource-reference/scanner.d.ts

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

package/dist/relations/resource-reference/scanner.js

@@ -0,0 +1,46 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceReferenceScanner = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const decorator_1 = require("./decorator");
+const token_1 = require("../../resource/token");
+const base_resource_field_1 = require("../../base-resource-field");
+let ResourceReferenceScanner = class ResourceReferenceScanner extends base_resource_field_1.ResourceFieldScanner {
+    referenceResources;
+    reflector;
+    constructor(referenceResources, reflector) {
+        super(referenceResources);
+        this.referenceResources = referenceResources;
+        this.reflector = reflector;
+    }
+    getMetadata(target) {
+        const references = this.reflector.get(decorator_1.RESOURCE_REFERENCE_METADATA, target);
+        if (!references) {
+            return [];
+        }
+        return references.map(({ targetModel, propertyKey }) => ({
+            sourceModel: target,
+            targetModel,
+            propertyKey,
+        }));
+    }
+};
+exports.ResourceReferenceScanner = ResourceReferenceScanner;
+exports.ResourceReferenceScanner = ResourceReferenceScanner = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, token_1.InjectMahmoudResources)()),
+    __metadata("design:paramtypes", [Array, core_1.Reflector])
+], ResourceReferenceScanner);

package/dist/relations/resource-reference/type.d.ts

@@ -0,0 +1,6 @@
+import { Type } from "@nestjs/common";
+export interface IResourceReference<T, K> {
+    sourceModel: Type<T>;
+    targetModel: Type<K>;
+    propertyKey: string;
+}

package/dist/relations/resource-reference/type.js

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

package/dist/relations/resource-resolver.service.d.ts

@@ -0,0 +1,20 @@
+import { Type } from "@nestjs/common";
+import { ResourceProviderRegistry } from "./resource-provider/registry";
+import { ResourceReferenceRegistry } from "./resource-reference/registry";
+interface ResourceResolveState {
+    rootType: Type;
+    rootResource: unknown;
+    resourceCache?: Map<Type, unknown>;
+}
+export declare class ResourceResolverService {
+    private readonly resourceReferences;
+    private readonly resourceProviders;
+    private readonly routeCache;
+    constructor(resourceReferences: ResourceReferenceRegistry, resourceProviders: ResourceProviderRegistry);
+    resolve<T>(state: ResourceResolveState, target: Type<T>): Promise<T>;
+    private findRoutes;
+    private cacheRoutes;
+    private resolveRoute;
+    private resolveReference;
+}
+export {};

package/dist/relations/resource-resolver.service.js

@@ -0,0 +1,137 @@
+"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.ResourceResolverService = void 0;
+const common_1 = require("@nestjs/common");
+const common_2 = require("@mahmoud-auth/common");
+const missing_resource_provider_exception_1 = require("../errors/missing-resource-provider.exception");
+const missing_transition_exception_1 = require("../errors/missing-transition.exception");
+const registry_1 = require("./resource-provider/registry");
+const registry_2 = require("./resource-reference/registry");
+let ResourceResolverService = class ResourceResolverService {
+    resourceReferences;
+    resourceProviders;
+    routeCache = new Map();
+    constructor(resourceReferences, resourceProviders) {
+        this.resourceReferences = resourceReferences;
+        this.resourceProviders = resourceProviders;
+    }
+    async resolve(state, target) {
+        const routes = this.findRoutes(state.rootType, target);
+        const result = await routes.reduce(async (previousResult, route) => {
+            const previous = await previousResult;
+            if (previous.found) {
+                return previous;
+            }
+            return this.resolveRoute(state, target, route);
+        }, Promise.resolve({ found: false, resource: undefined }));
+        if (!result.found) {
+            throw new missing_transition_exception_1.MissingTransitionException(state.rootType.name, target.name);
+        }
+        return result.resource;
+    }
+    findRoutes(from, target) {
+        const cachedRoutes = this.routeCache.get(from)?.get(target);
+        if (cachedRoutes) {
+            return cachedRoutes;
+        }
+        if (from.name === target.name) {
+            return this.cacheRoutes(from, target, [[]]);
+        }
+        const pendingRoutes = new Set([
+            { model: from, steps: [], visitedModels: new Set([from.name]) },
+        ]);
+        const routes = [];
+        pendingRoutes.forEach(currentRoute => {
+            this.resourceReferences.getFrom(currentRoute.model).forEach(reference => {
+                const steps = [
+                    ...currentRoute.steps,
+                    {
+                        targetModel: reference.targetModel,
+                        propertyKey: reference.propertyKey,
+                    },
+                ];
+                if (reference.targetModel.name === target.name) {
+                    routes.push(steps);
+                    return;
+                }
+                if (currentRoute.visitedModels.has(reference.targetModel.name)) {
+                    return;
+                }
+                const visitedModels = new Set(currentRoute.visitedModels);
+                visitedModels.add(reference.targetModel.name);
+                pendingRoutes.add({ model: reference.targetModel, steps, visitedModels });
+            });
+        });
+        if (routes.length === 0) {
+            throw new missing_transition_exception_1.MissingTransitionException(from.name, target.name);
+        }
+        return this.cacheRoutes(from, target, routes);
+    }
+    cacheRoutes(from, target, routes) {
+        const routesFromSource = this.routeCache.get(from)
+            ?? new Map();
+        if (!this.routeCache.has(from)) {
+            this.routeCache.set(from, routesFromSource);
+        }
+        routesFromSource.set(target, routes);
+        return routes;
+    }
+    async resolveRoute(state, target, route) {
+        const resourceCache = state.resourceCache ?? null;
+        const resolvedResources = new Map();
+        const result = await route.reduce(async (previousResult, step) => {
+            const previous = await previousResult;
+            if (previous.missing) {
+                return previous;
+            }
+            const resolvedResource = await this.resolveReference(previous.resource, step, resourceCache);
+            if (!(0, common_2.isNotNull)(resolvedResource)) {
+                return { missing: true, resource: undefined };
+            }
+            resolvedResources.set(step.targetModel, resolvedResource);
+            return { missing: false, resource: resolvedResource };
+        }, Promise.resolve({ missing: false, resource: state.rootResource }));
+        if (result.missing) {
+            return { found: false, resource: undefined };
+        }
+        resolvedResources.forEach((resource, resourceType) => resourceCache?.set(resourceType, resource));
+        return { found: true, resource: result.resource };
+    }
+    async resolveReference(resource, reference, resourceCache) {
+        const cachedResource = resourceCache?.get(reference.targetModel);
+        if (cachedResource) {
+            return cachedResource;
+        }
+        if (typeof resource !== 'object' || resource === null) {
+            return undefined;
+        }
+        const id = resource[reference.propertyKey];
+        if (!id) {
+            return undefined;
+        }
+        const provider = this.resourceProviders.get(reference.targetModel);
+        if (!provider) {
+            throw new missing_resource_provider_exception_1.MissingResourceProviderException(reference.targetModel.name);
+        }
+        const resolvedResource = await provider(id);
+        if ((0, common_2.isNotNull)(resolvedResource) && resourceCache) {
+            resourceCache.set(reference.targetModel, resolvedResource);
+        }
+        return resolvedResource;
+    }
+};
+exports.ResourceResolverService = ResourceResolverService;
+exports.ResourceResolverService = ResourceResolverService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [registry_2.ResourceReferenceRegistry,
+        registry_1.ResourceProviderRegistry])
+], ResourceResolverService);

package/dist/resource/index.d.ts

@@ -0,0 +1 @@
+export * from './token';

package/dist/resource/index.js

@@ -0,0 +1,17 @@
+"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("./token"), exports);

package/dist/resource/token.d.ts

@@ -0,0 +1,4 @@
+import { IUseValueWithToken, IUseFactoryWithToken } from "@mahmoud-auth/utils";
+export declare const InjectMahmoudResources: () => PropertyDecorator & ParameterDecorator;
+export declare const useValueMahmoudResources: IUseValueWithToken;
+export declare const useFactoryMahmoudResources: IUseFactoryWithToken;

package/dist/resource/token.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFactoryMahmoudResources = exports.useValueMahmoudResources = exports.InjectMahmoudResources = void 0;
+const common_1 = require("@nestjs/common");
+const utils_1 = require("@mahmoud-auth/utils");
+const MAHMOUD_RESOURCES = Symbol('MAHMOUD_RESOURCES');
+const InjectMahmoudResources = () => (0, common_1.Inject)(MAHMOUD_RESOURCES);
+exports.InjectMahmoudResources = InjectMahmoudResources;
+const useValueMahmoudResources = (resources, ...rest) => (0, utils_1.useValue)(MAHMOUD_RESOURCES, resources, ...rest);
+exports.useValueMahmoudResources = useValueMahmoudResources;
+const useFactoryMahmoudResources = (...rest) => (0, utils_1.useFactory)(MAHMOUD_RESOURCES, ...rest);
+exports.useFactoryMahmoudResources = useFactoryMahmoudResources;

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

@@ -0,0 +1,17 @@
+import { ClientSession, RootFilterQuery } from 'mongoose';
+export interface CascadeDeleteOptions {
+    /** Reuses a caller-owned transaction for selection and every cascade write. */
+    session?: ClientSession;
+}
+export interface CascadeDeleteResult {
+    acknowledged: boolean;
+    /** Number of selected root-model documents deleted; child cascades are not included. */
+    deletedCount: number;
+}
+export interface ICascadeHelperRepository<T, Id = unknown> {
+    getIdKey(id: Id): string;
+    findIds(filter: RootFilterQuery<T>, options?: CascadeDeleteOptions): Promise<Id[]>;
+    findIdsByField(field: string, value: unknown, options?: CascadeDeleteOptions): Promise<Id[]>;
+    nullifyByField(field: string, value: unknown, options?: CascadeDeleteOptions): Promise<void>;
+    deleteById(id: Id, options?: CascadeDeleteOptions): Promise<unknown | null>;
+}

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

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

package/dist/resource-cascade/base/base-model.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "@nestjs/common";
+import { CascadeService } from "./base-service";
+import { Model, RootFilterQuery } from 'mongoose';
+import { CascadeDeleteOptions, CascadeDeleteResult } from './base-cascade-helper.repository';
+export declare class CascadeModel<T, Id = unknown> {
+    readonly model: Model<T>;
+    private readonly cascadeService;
+    private readonly type;
+    constructor(model: Model<T>, cascadeService: CascadeService, type: Type<T>);
+    deleteById(id: Id, options?: CascadeDeleteOptions): Promise<unknown | null>;
+    deleteOne(filter: RootFilterQuery<T>, options?: CascadeDeleteOptions): Promise<CascadeDeleteResult>;
+    deleteMany(filter: RootFilterQuery<T>, options?: CascadeDeleteOptions): Promise<CascadeDeleteResult>;
+}

package/dist/resource-cascade/base/base-model.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeModel = void 0;
+class CascadeModel {
+    model;
+    cascadeService;
+    type;
+    constructor(model, cascadeService, type) {
+        this.model = model;
+        this.cascadeService = cascadeService;
+        this.type = type;
+    }
+    async deleteById(id, options) {
+        return this.cascadeService.cascadeById(this.type, id, options);
+    }
+    async deleteOne(filter, options) {
+        const query = options
+            ? this.model.findOne(filter, { _id: 1 }, options)
+            : this.model.findOne(filter, { _id: 1 });
+        const document = await query.lean();
+        if (!document || document._id === null || document._id === undefined) {
+            return { acknowledged: true, deletedCount: 0 };
+        }
+        const deletedDocument = await this.deleteById(document._id, options);
+        return { acknowledged: true, deletedCount: deletedDocument === null ? 0 : 1 };
+    }
+    async deleteMany(filter, options) {
+        const query = options
+            ? this.model.find(filter, { _id: 1 }, options)
+            : this.model.find(filter, { _id: 1 });
+        const documents = await query.lean();
+        let deletedCount = 0;
+        for (const document of documents) {
+            const deletedDocument = await this.deleteById(document._id, options);
+            if (deletedDocument !== null) {
+                deletedCount += 1;
+            }
+        }
+        return { acknowledged: true, deletedCount };
+    }
+}
+exports.CascadeModel = CascadeModel;

package/dist/resource-cascade/base/base-service.d.ts

@@ -0,0 +1,12 @@
+import { Type } from "@nestjs/common";
+import { ResourceCascadeRegistry } from "../registry";
+import { CascadeDeleteOptions } from "./base-cascade-helper.repository";
+import { CascadeRepositoryRegistry } from "./repository-registry";
+export declare class CascadeService {
+    private readonly registry;
+    private readonly repositories;
+    constructor(registry: ResourceCascadeRegistry, repositories: CascadeRepositoryRegistry);
+    cascadeById<T, Id>(type: Type<T>, id: Id, options?: CascadeDeleteOptions): Promise<unknown | null>;
+    private assertRepositoriesAvailable;
+    private deleteRecursive;
+}

package/dist/resource-cascade/base/base-service.js

@@ -0,0 +1,82 @@
+"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.CascadeService = void 0;
+const common_1 = require("@nestjs/common");
+const enum_1 = require("../enum");
+const registry_1 = require("../registry");
+const repository_registry_1 = require("./repository-registry");
+let CascadeService = class CascadeService {
+    registry;
+    repositories;
+    constructor(registry, repositories) {
+        this.registry = registry;
+        this.repositories = repositories;
+    }
+    async cascadeById(type, id, options) {
+        this.assertRepositoriesAvailable(type, new Set());
+        return this.deleteRecursive(type, id, new Map(), options);
+    }
+    assertRepositoriesAvailable(type, visited) {
+        if (visited.has(type)) {
+            return;
+        }
+        visited.add(type);
+        if (!this.repositories.get(type)) {
+            throw new Error(`Missing cascade repository for ${type.name}`);
+        }
+        for (const cascade of this.registry.getReferencing(type)) {
+            if (cascade.type !== enum_1.CascadeType.DELETE && cascade.type !== enum_1.CascadeType.NULL) {
+                throw new Error(`Invalid cascade type for ${cascade.sourceModel.name}.${cascade.propertyKey}`);
+            }
+            if (!this.repositories.get(cascade.sourceModel)) {
+                throw new Error(`Missing cascade repository for ${cascade.sourceModel.name}`);
+            }
+            if (cascade.type === enum_1.CascadeType.DELETE) {
+                this.assertRepositoriesAvailable(cascade.sourceModel, visited);
+            }
+        }
+    }
+    async deleteRecursive(type, id, visited, options) {
+        const repository = this.repositories.get(type);
+        if (!repository) {
+            throw new Error(`Missing cascade repository for ${type.name}`);
+        }
+        const visitedIds = visited.get(type) ?? new Set();
+        const key = repository.getIdKey(id);
+        if (visitedIds.has(key)) {
+            return null;
+        }
+        visitedIds.add(key);
+        visited.set(type, visitedIds);
+        for (const cascade of this.registry.getReferencing(type)) {
+            const sourceRepository = this.repositories.get(cascade.sourceModel);
+            if (!sourceRepository) {
+                throw new Error(`Missing cascade repository for ${cascade.sourceModel.name}`);
+            }
+            if (cascade.type === enum_1.CascadeType.NULL) {
+                await sourceRepository.nullifyByField(cascade.propertyKey, id, options);
+                continue;
+            }
+            const sourceIds = await sourceRepository.findIdsByField(cascade.propertyKey, id, options);
+            for (const sourceId of sourceIds) {
+                await this.deleteRecursive(cascade.sourceModel, sourceId, visited, options);
+            }
+        }
+        return repository.deleteById(id, options);
+    }
+};
+exports.CascadeService = CascadeService;
+exports.CascadeService = CascadeService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [registry_1.ResourceCascadeRegistry,
+        repository_registry_1.CascadeRepositoryRegistry])
+], CascadeService);

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

@@ -0,0 +1,7 @@
+import { Type } from '@nestjs/common';
+import { ICascadeHelperRepository } from './base-cascade-helper.repository';
+export declare class CascadeRepositoryRegistry {
+    private readonly repositories;
+    constructor(repositories: ReadonlyMap<Type, ICascadeHelperRepository<unknown>>);
+    get<T>(type: Type<T>): ICascadeHelperRepository<T> | undefined;
+}