meteorjs-decorators 1.0.0

package/dist/decorators/publication.decorator.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publication = Publication;
+require("reflect-metadata");
+const container_1 = require("../utils/container");
+const forward_ref_1 = require("../utils/forward-ref");
+const inject_decorator_1 = require("./inject.decorator");
+function Publication(name) {
+    return function (constructor) {
+        const paramTypes = Reflect.getMetadata('design:paramtypes', constructor) || [];
+        const injectTokens = (0, inject_decorator_1.getInjectTokens)(constructor);
+        // TODO: each publicatinon should be added to the module.
+        const resolveContainer = () => {
+            let current = constructor;
+            while (current && !current.__container) {
+                current = Object.getPrototypeOf(current);
+            }
+            return current?.__container || container_1.Container;
+        };
+        const buildInstance = () => {
+            const container = resolveContainer();
+            const args = paramTypes.map((type, index) => {
+                const injectionToken = resolveInjectionToken(type, injectTokens[index], constructor.name, index);
+                return container.get(injectionToken);
+            });
+            return new constructor(...args);
+        };
+        console.log('registering publication: ', name);
+        Meteor.publish(name, function (...args) {
+            const instance = buildInstance();
+            instance.__context = this;
+            return instance.init(...args);
+        });
+    };
+}
+function resolveInjectionToken(reflectedType, customToken, targetName, index) {
+    if (customToken) {
+        return unwrapToken(customToken);
+    }
+    if (!reflectedType) {
+        throw new Error(`Cannot resolve dependency for ${targetName}. Parameter at index ${index} is undefined. ` +
+            'Consider using @Inject with forwardRef to resolve circular dependencies.');
+    }
+    return reflectedType.name;
+}
+function unwrapToken(token) {
+    if (typeof token === 'string') {
+        return token;
+    }
+    if (token instanceof forward_ref_1.ForwardRef) {
+        return token.get().name;
+    }
+    return token().name;
+}

package/dist/decorators/reactive-dto.decorator.d.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import { ResponseDto } from '../dtos/response.dto';
+import { Type } from '../types/type.interface';
+export declare function ReactiveDto(dto: Type<ResponseDto>): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/decorators/reactive-dto.decorator.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactiveDto = ReactiveDto;
+require("reflect-metadata");
+function ReactiveDto(dto) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const cursor = originalMethod.apply(this, args);
+            const subscription = this?.__context;
+            if (!subscription || !cursor || typeof cursor.observe !== 'function') {
+                return cursor;
+            }
+            const collectionName = getCollectionName(cursor);
+            if (!collectionName) {
+                throw new Meteor.Error('publication-error', 'Cannot resolve collection name for reactive publication.');
+            }
+            const toDto = (doc) => ({
+                ...new dto().build(doc),
+            });
+            const handle = cursor.observe({
+                added(doc) {
+                    subscription.added(collectionName, doc._id, toDto(doc));
+                },
+                changed(newDoc) {
+                    subscription.changed(collectionName, newDoc._id, toDto(newDoc));
+                },
+                removed(oldDoc) {
+                    subscription.removed(collectionName, oldDoc._id);
+                },
+            });
+            subscription.onStop(() => {
+                if (typeof handle?.stop === 'function') {
+                    handle.stop();
+                }
+            });
+            subscription.ready();
+        };
+        return descriptor;
+    };
+}
+function getCollectionName(cursor) {
+    return cursor?._cursorDescription?.collectionName
+        || cursor?._collection?._name
+        || cursor?.collection?._name
+        || cursor?.collectionName
+        || cursor?.name;
+}

package/dist/decorators/validate.decorator.d.ts

@@ -0,0 +1,3 @@
+import { RequestDto } from "../dtos/request.dto";
+import { Type } from "../types/type.interface";
+export declare function Validate(...dtos: Type<RequestDto>[] | String[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/decorators/validate.decorator.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = Validate;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+function Validate(...dtos) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            const STRING_TYPE = 'string';
+            const BOOLEAN_TYPE = 'boolean';
+            const NUMBER_TYPE = 'number';
+            const OBJECT_TYPE = 'object';
+            const ARRAY_TYPE = 'array';
+            for (let i = 0; i < args.length; i++) {
+                if (dtos.length < i + 1) {
+                    continue; // do not validate rest of parameters
+                }
+                let validation = true;
+                switch (typeof dtos[i] === 'string' ? dtos[i] : 'object') {
+                    case STRING_TYPE:
+                        validation = typeof args[i] === STRING_TYPE;
+                        break;
+                    case BOOLEAN_TYPE:
+                        validation = typeof args[i] === BOOLEAN_TYPE;
+                        break;
+                    case NUMBER_TYPE:
+                        validation = typeof args[i] === NUMBER_TYPE;
+                        break;
+                    case OBJECT_TYPE:
+                    case ARRAY_TYPE:
+                        const requestDto = (0, class_transformer_1.plainToInstance)(dtos[i], args[i]); // Transform argument into DTO class
+                        const errors = (0, class_validator_1.validateSync)(requestDto);
+                        if (errors.length > 0) {
+                            const details = errors
+                                .flatMap((error) => Object.values(error.constraints ?? {}).map((message) => `${error.property}: ${message}`))
+                                .join('; ');
+                            throw new Meteor.Error('validation-error', 'Validation failed', details || 'Validation failed');
+                        }
+                        // Replace object argument with validated DTO
+                        args[i] = requestDto;
+                        break;
+                    default:
+                        throw new Meteor.Error('validation-error', 'Validation failed', `Parameter ${i + 1} has not a valid type.`);
+                }
+                if (validation === false) {
+                    throw new Meteor.Error('validation-error', 'Validation failed', `Parameter ${i + 1} is not ${STRING_TYPE} type`);
+                }
+            }
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}

package/dist/dtos/delete-response.dto.d.ts

@@ -0,0 +1,6 @@
+import { ResponseDto } from "./response.dto";
+export declare class DeleteResponse extends ResponseDto {
+    status: number;
+    message: string;
+    build(): DeleteResponse;
+}

package/dist/dtos/delete-response.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteResponse = void 0;
+const response_dto_1 = require("./response.dto");
+class DeleteResponse extends response_dto_1.ResponseDto {
+    build() {
+        this.status = 200;
+        this.message = 'Record deleted!';
+        return this.send();
+    }
+}
+exports.DeleteResponse = DeleteResponse;

package/dist/dtos/pagination-request.dto.d.ts

@@ -0,0 +1,5 @@
+import { RequestDto } from './request.dto';
+export declare class PaginationRequestDto extends RequestDto {
+    page: number;
+    limit: number;
+}

package/dist/dtos/pagination-request.dto.js

@@ -0,0 +1,36 @@
+"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.PaginationRequestDto = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const request_dto_1 = require("./request.dto");
+class PaginationRequestDto extends request_dto_1.RequestDto {
+    constructor() {
+        super(...arguments);
+        this.page = 1;
+        this.limit = 10;
+    }
+}
+exports.PaginationRequestDto = PaginationRequestDto;
+__decorate([
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    __metadata("design:type", Number)
+], PaginationRequestDto.prototype, "page", void 0);
+__decorate([
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(100),
+    __metadata("design:type", Number)
+], PaginationRequestDto.prototype, "limit", void 0);

package/dist/dtos/request.dto.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export declare abstract class RequestDto {
+}

package/dist/dtos/request.dto.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestDto = void 0;
+require("reflect-metadata"); // for specific decorators from class-validator
+class RequestDto {
+}
+exports.RequestDto = RequestDto;

package/dist/dtos/response.dto.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class ResponseDto {
+    abstract build(...args: unknown[]): ResponseDto;
+    protected send(): this;
+    /**
+     * Method to return undefined values from dto with NULL values.
+     * This helps to keep the original structure.
+     * @private
+     */
+    private preserveNulls;
+}

package/dist/dtos/response.dto.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseDto = void 0;
+class ResponseDto {
+    send() {
+        this.preserveNulls();
+        return this;
+    }
+    /**
+     * Method to return undefined values from dto with NULL values.
+     * This helps to keep the original structure.
+     * @private
+     */
+    preserveNulls() {
+        for (const [field, value] of Object.entries(this)) {
+            this[field] = value ?? null;
+        }
+    }
+}
+exports.ResponseDto = ResponseDto;

package/dist/entities/base.entity.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class BaseEntity {
+    static collection: Mongo.Collection<any>;
+}
+export type EntityConstructor<T> = typeof BaseEntity & {
+    new (...args: any[]): T;
+    collection: Mongo.Collection<T>;
+};

package/dist/entities/base.entity.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntity = void 0;
+class BaseEntity {
+}
+exports.BaseEntity = BaseEntity;

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export * from './controllers/base.controller';
+export * from './decorators/auth-guard.decorator';
+export * from './decorators/controller.decorator';
+export * from './decorators/dto.decorator';
+export * from './decorators/entity.decorator';
+export * from './decorators/inject.decorator';
+export * from './decorators/injectable.decorator';
+export * from './decorators/method.decorator';
+export * from './decorators/permissions.decorator';
+export * from './decorators/publication.decorator';
+export * from './decorators/reactive-dto.decorator';
+export * from './decorators/validate.decorator';
+export * from './dtos/delete-response.dto';
+export * from './dtos/pagination-request.dto';
+export * from './dtos/request.dto';
+export * from './dtos/response.dto';
+export * from './entities/base.entity';
+export * from './publications/base.publication';
+export * from './types/type.interface';
+export * from './utils/container';
+export * from './utils/forward-ref';
+export * from './utils/module';

package/dist/index.js

@@ -0,0 +1,38 @@
+"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("./controllers/base.controller"), exports);
+__exportStar(require("./decorators/auth-guard.decorator"), exports);
+__exportStar(require("./decorators/controller.decorator"), exports);
+__exportStar(require("./decorators/dto.decorator"), exports);
+__exportStar(require("./decorators/entity.decorator"), exports);
+__exportStar(require("./decorators/inject.decorator"), exports);
+__exportStar(require("./decorators/injectable.decorator"), exports);
+__exportStar(require("./decorators/method.decorator"), exports);
+__exportStar(require("./decorators/permissions.decorator"), exports);
+__exportStar(require("./decorators/publication.decorator"), exports);
+__exportStar(require("./decorators/reactive-dto.decorator"), exports);
+__exportStar(require("./decorators/validate.decorator"), exports);
+__exportStar(require("./dtos/delete-response.dto"), exports);
+__exportStar(require("./dtos/pagination-request.dto"), exports);
+__exportStar(require("./dtos/request.dto"), exports);
+__exportStar(require("./dtos/response.dto"), exports);
+__exportStar(require("./entities/base.entity"), exports);
+__exportStar(require("./publications/base.publication"), exports);
+__exportStar(require("./types/type.interface"), exports);
+__exportStar(require("./utils/container"), exports);
+__exportStar(require("./utils/forward-ref"), exports);
+__exportStar(require("./utils/module"), exports);

package/dist/publications/base.publication.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class BasePublication {
+    __context: Subscription;
+    abstract init(...args: any[]): Mongo.Cursor<any>;
+}

package/dist/publications/base.publication.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePublication = void 0;
+class BasePublication {
+}
+exports.BasePublication = BasePublication;

package/dist/types/type.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}

package/dist/types/type.interface.js

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

package/dist/utils/container.d.ts

@@ -0,0 +1,26 @@
+import { ForwardRef } from './forward-ref';
+export interface ContainerAware {
+    __container?: ModuleContainer;
+}
+export declare class ModuleContainer {
+    private instances;
+    private factories;
+    private proxies;
+    private resolving;
+    private parent?;
+    constructor(parent?: ModuleContainer);
+    set<T>(token: string, value: T | ForwardRef<T>): void;
+    register<T>(token: string, factory: () => T): void;
+    get<T>(token: string): T;
+    has(token: string): boolean;
+    clear(): void;
+    private getProxy;
+}
+export declare class Container {
+    private static rootContainer;
+    static set<T>(token: string, value: T | ForwardRef<T>): void;
+    static register<T>(token: string, factory: () => T): void;
+    static get<T>(token: string): T;
+    static has(token: string): boolean;
+    static createChildContainer(): ModuleContainer;
+}

package/dist/utils/container.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = exports.ModuleContainer = void 0;
+const forward_ref_1 = require("./forward-ref");
+class ModuleContainer {
+    constructor(parent) {
+        this.instances = new Map();
+        this.factories = new Map();
+        this.proxies = new Map();
+        this.resolving = new Set();
+        this.parent = parent;
+    }
+    set(token, value) {
+        this.instances.set(token, value);
+    }
+    register(token, factory) {
+        this.factories.set(token, factory);
+    }
+    get(token) {
+        if (this.instances.has(token)) {
+            const instance = this.instances.get(token);
+            if (instance instanceof forward_ref_1.ForwardRef) {
+                return instance.get();
+            }
+            return instance;
+        }
+        if (this.resolving.has(token)) {
+            return this.getProxy(token);
+        }
+        if (this.factories.has(token)) {
+            this.resolving.add(token);
+            const instance = this.factories.get(token)();
+            this.resolving.delete(token);
+            this.instances.set(token, instance);
+            return instance;
+        }
+        if (this.parent) {
+            return this.parent.get(token);
+        }
+        return undefined;
+    }
+    has(token) {
+        return this.instances.has(token) || this.factories.has(token) || (this.parent?.has(token) ?? false);
+    }
+    clear() {
+        this.instances.clear();
+        this.factories.clear();
+        this.proxies.clear();
+        this.resolving.clear();
+    }
+    getProxy(token) {
+        if (!this.proxies.has(token)) {
+            const handler = {
+                get: (_target, prop) => {
+                    const instance = this.instances.get(token);
+                    if (!instance) {
+                        throw new Error(`Circular dependency detected for token ${token}.`);
+                    }
+                    const value = instance[prop];
+                    return typeof value === 'function' ? value.bind(instance) : value;
+                },
+                set: (_target, prop, value) => {
+                    const instance = this.instances.get(token);
+                    if (!instance) {
+                        throw new Error(`Circular dependency detected for token ${token}.`);
+                    }
+                    instance[prop] = value;
+                    return true;
+                }
+            };
+            this.proxies.set(token, new Proxy({}, handler));
+        }
+        return this.proxies.get(token);
+    }
+}
+exports.ModuleContainer = ModuleContainer;
+// Global container for backward compatibility
+class Container {
+    static set(token, value) {
+        this.rootContainer.set(token, value);
+    }
+    static register(token, factory) {
+        this.rootContainer.register(token, factory);
+    }
+    static get(token) {
+        return this.rootContainer.get(token);
+    }
+    static has(token) {
+        return this.rootContainer.has(token);
+    }
+    static createChildContainer() {
+        return new ModuleContainer(this.rootContainer);
+    }
+}
+exports.Container = Container;
+Container.rootContainer = new ModuleContainer();

package/dist/utils/forward-ref.d.ts

@@ -0,0 +1,6 @@
+export declare class ForwardRef<T> {
+    private readonly fn;
+    constructor(fn: () => T);
+    get(): T;
+}
+export declare function forwardRef<T>(fn: () => T): ForwardRef<T>;

package/dist/utils/forward-ref.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForwardRef = void 0;
+exports.forwardRef = forwardRef;
+class ForwardRef {
+    constructor(fn) {
+        this.fn = fn;
+    }
+    get() {
+        return this.fn();
+    }
+}
+exports.ForwardRef = ForwardRef;
+function forwardRef(fn) {
+    return new ForwardRef(fn);
+}

package/dist/utils/module.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export declare function Module(config: {
+    imports?: any[];
+    providers?: any[];
+    controllers?: any[];
+}): (target: any) => void;

package/dist/utils/module.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = Module;
+require("reflect-metadata");
+const container_1 = require("./container");
+function Module(config) {
+    return function (target) {
+        // Create a container for this module
+        const moduleContainer = container_1.Container.createChildContainer();
+        // Handle imports first
+        if (config.imports) {
+            config.imports.forEach(importedModule => {
+                // Don't instantiate modules directly, just register them
+                if (importedModule.forwardRef) {
+                    console.log('importedModule4: ', importedModule.forwardRef.get());
+                    moduleContainer.set(importedModule.forwardRef.get().name, importedModule.forwardRef.get());
+                }
+                else {
+                    moduleContainer.set(importedModule.name, importedModule);
+                }
+            });
+        }
+        const resolveProvider = (providerClass) => {
+            if (container_1.Container.has(providerClass.name)) {
+                moduleContainer.set(providerClass.name, container_1.Container.get(providerClass.name));
+                return;
+            }
+            const paramTypes = Reflect.getMetadata('design:paramtypes', providerClass) || [];
+            const args = paramTypes.map((type) => moduleContainer.get(type.name));
+            moduleContainer.set(providerClass.name, new providerClass(...args));
+        };
+        // Then handle providers
+        if (config.providers) {
+            config.providers.forEach(provider => {
+                if (typeof provider === 'function') {
+                    resolveProvider(provider);
+                }
+                else if (provider.forwardRef) {
+                    resolveProvider(provider.forwardRef.get());
+                }
+            });
+        }
+        // Handle controllers
+        if (config.controllers) {
+            config.controllers.forEach(controller => {
+                if (typeof controller === 'function') {
+                    let instance;
+                    if (container_1.Container.has(controller.name)) {
+                        instance = container_1.Container.get(controller.name);
+                    }
+                    else {
+                        const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+                        const args = paramTypes.map((type) => moduleContainer.get(type.name));
+                        instance = new controller(...args);
+                    }
+                    moduleContainer.set(controller.name, instance);
+                    controller.__container = moduleContainer;
+                }
+            });
+        }
+        // Store the container in the module class
+        target.__container = moduleContainer;
+    };
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "meteorjs-decorators",
+  "version": "1.0.0",
+  "description": "Meteor decorators to make your Meteor app with NestJS-style pattern.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Ivan Cabrera",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/meteor": "^2.0.0",
+    "mongodb": "^6.13.1",
+    "typescript": "^5.4.5"
+  }
+}