tspace-mysql/dist/lib/core/Nest/index.js

Tspace MySQL is a promise-based ORM for Node.js, designed with modern TypeScript and providing type safety for schema databases.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Nest = void 0;
require("reflect-metadata");
const __1 = require("..");
class Nest {
    /**
     * Factory function for creating a provider definition for a given model.
     *
     * This utility helps register either a repository instance or a model instance
     * with a dependency injection system (e.g. NestJS). It returns an object
     * compatible with DI containers expecting `{ provide, useValue }`.
     *
     * @template M - The type of the model extending `Model`.
     * @param {Model} model - The constructor function of the model to provide.
     * @param {{ pattern?: 'repository' | 'model' }} [options={ pattern: 'repository' }]
     * The provider options:
     * - `pattern: 'repository'` (default) → provide a repository wrapper for the model.
     * - `pattern: 'model'` → provide a direct model instance.
     *
     * @returns {{ provide: string; useValue: unknown }}
     * The provider definition object containing:
     * - `provide`: The injection token, derived from the model name.
     * - `useValue`: The repository or model instance.
     *
     * @example
     * ```ts
     * // src/app.module.ts;
     *
     * import { Module } from '@nestjs/common';
     * import { AppController } from './app.controller';
     * import { AppService } from './app.service';
     * import { Nest } from 'tspace-mysql';
     * import { User } from './entities/user.entity'
     *
     * @Module({
     *   controllers: [AppController],
     *   providers: [AppService, Nest.Provider(User)] // register this
     * })
     *
     * export class AppModule {}
     * ```
     */
    static Provider = (model, options = { pattern: 'repository' }) => {
        return {
            provide: this._paramToken(model),
            useValue: options.pattern === 'repository'
                ? (0, __1.Repository)(model)
                : new __1.Model()
        };
    };
    /**
     * Parameter decorator factory for injecting a repository of a given model.
     *
     * This decorator is designed to work with dependency injection systems (e.g. NestJS).
     * It records metadata about constructor parameter dependencies so they can later
     * be resolved and injected automatically.
     *
     * @template M - The type of the model extending `Model`.
     * @param {Model} model - The constructor function of the model to inject.
     * @returns {Function}
     * A parameter decorator function that attaches repository injection metadata.
     *
     * @example
     * ```ts
     * import { Nest, T } from 'tspace-mysql'
     * class User extends Model {}
     *
     * class UserService {
     *   constructor(
     *      @Nest.InjectRepository(User)
     *      private readonly userRepo: T.Repository<User>
     *   ) {}
     * }
     * ```
     */
    static InjectRepository = (model) => {
        return (target, _, index) => {
            const meta = Reflect.getMetadata('self:paramtypes', target) || [];
            const param = this._paramToken(model);
            const dependencies = [...meta, { index, param }];
            Reflect.defineMetadata('self:paramtypes', dependencies, target);
        };
    };
    static _nameOfModel = (model) => {
        return `${new model().constructor?.name ?? Math.random().toString(36).slice(2)}@Repository`;
    };
    static _paramToken = (model) => {
        return typeof model === 'string'
            ? model
            : this._nameOfModel(model);
    };
}
exports.Nest = Nest;
//# sourceMappingURL=index.js.map