@miguelmorales13/nestkit 0.1.0

package/dist/chunk-JOVBJDJ2.js

@@ -0,0 +1,104 @@
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-4MGIQFAJ.js";
+
+// src/crud/crud.service.ts
+var BaseCrudService = class {
+  constructor(repository, options = {}) {
+    this.repository = repository;
+    this.options = options;
+  }
+  findById(id, tenantId) {
+    return this.repository.findById(id, tenantId);
+  }
+  findAll(filter, tenantId) {
+    return this.repository.findAll(filter, tenantId);
+  }
+  create(data, tenantId) {
+    return this.repository.create(data, tenantId);
+  }
+  update(id, data, tenantId) {
+    return this.repository.update(id, data, tenantId);
+  }
+  async delete(id, tenantId) {
+    if (this.options.deleteStrategy === "soft") {
+      await this.repository.update(id, { deletedAt: /* @__PURE__ */ new Date() }, tenantId);
+      return;
+    }
+    await this.repository.delete(id, tenantId);
+  }
+};
+
+// src/crud/crud.controller.ts
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Req
+} from "@nestjs/common";
+function createCrudController(serviceToken, options = {}) {
+  const tenantIdOf = (req) => options.tenantIdExtractor?.(req);
+  let CrudControllerHost = class {
+    constructor(service) {
+      this.service = service;
+    }
+    findAll(filter, req) {
+      return this.service.findAll(filter, tenantIdOf(req));
+    }
+    findById(id, req) {
+      return this.service.findById(id, tenantIdOf(req));
+    }
+    create(data, req) {
+      return this.service.create(data, tenantIdOf(req));
+    }
+    update(id, data, req) {
+      return this.service.update(id, data, tenantIdOf(req));
+    }
+    remove(id, req) {
+      return this.service.delete(id, tenantIdOf(req));
+    }
+  };
+  __decorateClass([
+    Get(),
+    __decorateParam(0, Query()),
+    __decorateParam(1, Req())
+  ], CrudControllerHost.prototype, "findAll", 1);
+  __decorateClass([
+    Get(":id"),
+    __decorateParam(0, Param("id")),
+    __decorateParam(1, Req())
+  ], CrudControllerHost.prototype, "findById", 1);
+  __decorateClass([
+    Post(),
+    __decorateParam(0, Body()),
+    __decorateParam(1, Req())
+  ], CrudControllerHost.prototype, "create", 1);
+  __decorateClass([
+    Patch(":id"),
+    __decorateParam(0, Param("id")),
+    __decorateParam(1, Body()),
+    __decorateParam(2, Req())
+  ], CrudControllerHost.prototype, "update", 1);
+  __decorateClass([
+    Delete(":id"),
+    __decorateParam(0, Param("id")),
+    __decorateParam(1, Req())
+  ], CrudControllerHost.prototype, "remove", 1);
+  CrudControllerHost = __decorateClass([
+    Controller(options.path ?? ""),
+    __decorateParam(0, Inject(serviceToken))
+  ], CrudControllerHost);
+  return CrudControllerHost;
+}
+
+export {
+  BaseCrudService,
+  createCrudController
+};

package/dist/chunk-KDAA6GFF.js

@@ -0,0 +1,29 @@
+import {
+  RequestContext
+} from "./chunk-EBO6UKHL.js";
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/response/response.interceptor.ts
+import { Injectable } from "@nestjs/common";
+import { map } from "rxjs/operators";
+var ResponseInterceptor = class {
+  intercept(_context, next) {
+    return next.handle().pipe(
+      map((data) => ({
+        success: true,
+        data,
+        requestId: RequestContext.getRequestId() ?? "unknown",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }))
+    );
+  }
+};
+ResponseInterceptor = __decorateClass([
+  Injectable()
+], ResponseInterceptor);
+
+export {
+  ResponseInterceptor
+};

package/dist/chunk-KP7GRCZW.js

@@ -0,0 +1,32 @@
+import {
+  ResponseInterceptor
+} from "./chunk-KDAA6GFF.js";
+import {
+  GlobalExceptionFilter
+} from "./chunk-EQXYK6AL.js";
+
+// src/bootstrap/apply-defaults.ts
+import {
+  ValidationPipe
+} from "@nestjs/common";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import helmet from "helmet";
+function applyNestKitDefaults(app, options = {}) {
+  app.use(helmet());
+  app.enableCors(options.cors ?? { origin: process.env.CORS_ORIGIN?.split(",") ?? true });
+  app.useGlobalPipes(
+    new ValidationPipe({ whitelist: true, transform: true, ...options.validation })
+  );
+  app.useGlobalFilters(new GlobalExceptionFilter());
+  app.useGlobalInterceptors(new ResponseInterceptor());
+  if (options.swagger !== false) {
+    const swaggerOptions = options.swagger ?? { title: "API" };
+    const config = new DocumentBuilder().setTitle(swaggerOptions.title).build();
+    const document = SwaggerModule.createDocument(app, config);
+    SwaggerModule.setup(swaggerOptions.path ?? "docs", app, document);
+  }
+}
+
+export {
+  applyNestKitDefaults
+};

package/dist/chunk-PA24P76K.js

@@ -0,0 +1,39 @@
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/database/supabase/supabase.module.ts
+import { Module } from "@nestjs/common";
+import { createClient } from "@supabase/supabase-js";
+var SUPABASE_ANON_CLIENT = /* @__PURE__ */ Symbol("SUPABASE_ANON_CLIENT");
+var SUPABASE_SERVICE_ROLE_CLIENT = /* @__PURE__ */ Symbol("SUPABASE_SERVICE_ROLE_CLIENT");
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`SupabaseModule: ${name} environment variable is not set`);
+  }
+  return value;
+}
+var SupabaseModule = class {
+};
+SupabaseModule = __decorateClass([
+  Module({
+    providers: [
+      {
+        provide: SUPABASE_ANON_CLIENT,
+        useFactory: () => createClient(requireEnv("SUPABASE_URL"), requireEnv("SUPABASE_ANON_KEY"))
+      },
+      {
+        provide: SUPABASE_SERVICE_ROLE_CLIENT,
+        useFactory: () => createClient(requireEnv("SUPABASE_URL"), requireEnv("SUPABASE_SERVICE_ROLE_KEY"))
+      }
+    ],
+    exports: [SUPABASE_ANON_CLIENT, SUPABASE_SERVICE_ROLE_CLIENT]
+  })
+], SupabaseModule);
+
+export {
+  SUPABASE_ANON_CLIENT,
+  SUPABASE_SERVICE_ROLE_CLIENT,
+  SupabaseModule
+};

package/dist/chunk-VKOPDDCC.js

@@ -0,0 +1,50 @@
+import {
+  __decorateClass
+} from "./chunk-4MGIQFAJ.js";
+
+// src/database/postgres/postgres.module.ts
+import { Module } from "@nestjs/common";
+import { Pool } from "pg";
+var PG_POOL = /* @__PURE__ */ Symbol("PG_POOL");
+var PgModule = class {
+};
+PgModule = __decorateClass([
+  Module({
+    providers: [
+      {
+        provide: PG_POOL,
+        useFactory: () => {
+          const connectionString = process.env.DATABASE_URL;
+          if (!connectionString) {
+            throw new Error("PgModule: DATABASE_URL environment variable is not set");
+          }
+          return new Pool({ connectionString });
+        }
+      }
+    ],
+    exports: [PG_POOL]
+  })
+], PgModule);
+
+// src/database/postgres/tenant-scope.ts
+async function withTenantScope(pool, authUserId, fn) {
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    await client.query("SELECT set_config('request.jwt.claim.sub', $1, true)", [authUserId]);
+    const result = await fn(client);
+    await client.query("COMMIT");
+    return result;
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+export {
+  PG_POOL,
+  PgModule,
+  withTenantScope
+};

package/dist/chunk-XX2HPTRU.js

@@ -0,0 +1,12 @@
+// src/entities/base-response.dto.ts
+var BaseResponseDto = class {
+  static fromEntity(entity) {
+    const dto = new this();
+    Object.assign(dto, entity);
+    return dto;
+  }
+};
+
+export {
+  BaseResponseDto
+};

package/dist/crud/crud.controller.d.ts

@@ -0,0 +1,39 @@
+import { type Type } from '@nestjs/common';
+import type { BaseEntity } from '../entities/base.entity.js';
+import type { BaseCrudService } from './crud.service.js';
+export interface CreateCrudControllerOptions {
+    /** Route prefix for the generated controller. Defaults to no prefix. */
+    path?: string;
+    /**
+     * Extracts the tenant id from the incoming request and forwards it to
+     * every service call (findAll/findById/create/update/remove). Required
+     * for multi-tenant use — without it, the generated controller behaves as
+     * single-tenant (no tenantId is ever passed to the Repository/service,
+     * same as omitting it manually). Typical implementation reads a value a
+     * guard already attached to the request, e.g. `(req) => req.companyId`.
+     */
+    tenantIdExtractor?: (req: unknown) => string | undefined;
+}
+/**
+ * Mixin factory (function returning a class) that wires up the standard
+ * REST verbs to a BaseCrudService — composition, not forced inheritance.
+ * Pass the service's class/token; Nest resolves it via constructor DI when
+ * the generated controller is instantiated, so the service must already be
+ * a provider in the module where this controller is declared.
+ *
+ * Usage (single-tenant):
+ *   class WidgetsController extends createCrudController(WidgetsService, { path: 'widgets' }) {}
+ *
+ * Usage (multi-tenant, e.g. behind a guard that sets req.companyId):
+ *   class WidgetsController extends createCrudController(WidgetsService, {
+ *     path: 'widgets',
+ *     tenantIdExtractor: (req) => (req as AuthenticatedRequest).companyId,
+ *   }) {}
+ */
+export declare function createCrudController<T extends BaseEntity>(serviceToken: Type<BaseCrudService<T>>, options?: CreateCrudControllerOptions): Type<{
+    findAll(filter: Partial<T> | undefined, req: unknown): Promise<T[]>;
+    findById(id: string, req: unknown): Promise<T | null>;
+    create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>, req: unknown): Promise<T>;
+    update(id: string, data: Partial<T>, req: unknown): Promise<T>;
+    remove(id: string, req: unknown): Promise<void>;
+}>;

package/dist/crud/crud.service.d.ts

@@ -0,0 +1,29 @@
+import type { BaseEntity } from '../entities/base.entity.js';
+import type { Repository } from './repository.port.js';
+export interface BaseCrudServiceOptions {
+    /**
+     * 'hard' (default): delete() calls repository.delete().
+     * 'soft': delete() calls repository.update(id, { deletedAt: new Date() })
+     * instead. When using 'soft', T must actually carry a `deletedAt` field
+     * (conform to SoftDeleteEntity) — not enforced via a generic constraint
+     * here so this class stays usable with plain BaseEntity under 'hard'
+     * deletes too. Type your repository as Repository<YourSoftDeleteEntity>
+     * if you always soft-delete.
+     */
+    deleteStrategy?: 'soft' | 'hard';
+}
+/**
+ * Generic CRUD orchestration on top of a Repository<T> port. Optional to
+ * use directly — extend it to add business rules, or bypass it and consume
+ * the Repository port directly.
+ */
+export declare class BaseCrudService<T extends BaseEntity> {
+    protected readonly repository: Repository<T>;
+    protected readonly options: BaseCrudServiceOptions;
+    constructor(repository: Repository<T>, options?: BaseCrudServiceOptions);
+    findById(id: string, tenantId?: string): Promise<T | null>;
+    findAll(filter?: Partial<T>, tenantId?: string): Promise<T[]>;
+    create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>, tenantId?: string): Promise<T>;
+    update(id: string, data: Partial<T>, tenantId?: string): Promise<T>;
+    delete(id: string, tenantId?: string): Promise<void>;
+}

package/dist/crud/index.d.ts

@@ -0,0 +1,5 @@
+export type { Repository } from './repository.port.js';
+export { BaseCrudService } from './crud.service.js';
+export type { BaseCrudServiceOptions } from './crud.service.js';
+export { createCrudController } from './crud.controller.js';
+export type { CreateCrudControllerOptions } from './crud.controller.js';

package/dist/crud/index.js

@@ -0,0 +1,9 @@
+import {
+  BaseCrudService,
+  createCrudController
+} from "../chunk-JOVBJDJ2.js";
+import "../chunk-4MGIQFAJ.js";
+export {
+  BaseCrudService,
+  createCrudController
+};

package/dist/crud/repository.port.d.ts

@@ -0,0 +1,14 @@
+import type { BaseEntity } from '../entities/base.entity.js';
+/**
+ * Persistence port every adapter (Postgres, Supabase, future Mongo, or a
+ * hand-rolled one) implements. `tenantId` is optional so the same port
+ * works for both multi-tenant (RLS-scoped) and single-tenant consumers —
+ * adapters that don't need it simply ignore the parameter.
+ */
+export interface Repository<T extends BaseEntity, ID = string> {
+    findById(id: ID, tenantId?: string): Promise<T | null>;
+    findAll(filter?: Partial<T>, tenantId?: string): Promise<T[]>;
+    create(data: Omit<T, 'id' | 'createdAt' | 'updatedAt'>, tenantId?: string): Promise<T>;
+    update(id: ID, data: Partial<T>, tenantId?: string): Promise<T>;
+    delete(id: ID, tenantId?: string): Promise<void>;
+}

package/dist/database/mongo/index.d.ts

@@ -0,0 +1 @@
+export type { MongoRepositoryPort } from './repository.port.js';

package/dist/database/mongo/index.js

@@ -0,0 +1 @@
+import "../../chunk-EPVKCBPT.js";

package/dist/database/mongo/repository.port.d.ts

@@ -0,0 +1 @@
+export type { Repository as MongoRepositoryPort } from '../../crud/repository.port.js';

package/dist/database/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export { PgModule, PG_POOL } from './postgres.module.js';
+export { withTenantScope } from './tenant-scope.js';

package/dist/database/postgres/index.js

@@ -0,0 +1,11 @@
+import {
+  PG_POOL,
+  PgModule,
+  withTenantScope
+} from "../../chunk-VKOPDDCC.js";
+import "../../chunk-4MGIQFAJ.js";
+export {
+  PG_POOL,
+  PgModule,
+  withTenantScope
+};

package/dist/database/postgres/postgres.module.d.ts

@@ -0,0 +1,4 @@
+/** DI token for the shared pg Pool. Inject with `@Inject(PG_POOL)`. */
+export declare const PG_POOL: unique symbol;
+export declare class PgModule {
+}

package/dist/database/postgres/tenant-scope.d.ts

@@ -0,0 +1,11 @@
+import type { Pool, PoolClient } from 'pg';
+/**
+ * Generalization of the RLS-scoped transaction pattern (`runAsOwner`):
+ * checks out a client, opens a transaction, sets
+ * `request.jwt.claim.sub = authUserId` via `set_config` (scoped to the
+ * transaction) so Postgres Row-Level-Security policies relying on
+ * `auth.uid()` see the correct tenant, runs `fn` with that client, commits
+ * on success / rolls back on error, and always releases the client back to
+ * the pool.
+ */
+export declare function withTenantScope<T>(pool: Pool, authUserId: string, fn: (client: PoolClient) => Promise<T>): Promise<T>;

package/dist/database/supabase/index.d.ts

@@ -0,0 +1 @@
+export { SupabaseModule, SUPABASE_ANON_CLIENT, SUPABASE_SERVICE_ROLE_CLIENT, } from './supabase.module.js';

package/dist/database/supabase/index.js

@@ -0,0 +1,11 @@
+import {
+  SUPABASE_ANON_CLIENT,
+  SUPABASE_SERVICE_ROLE_CLIENT,
+  SupabaseModule
+} from "../../chunk-PA24P76K.js";
+import "../../chunk-4MGIQFAJ.js";
+export {
+  SUPABASE_ANON_CLIENT,
+  SUPABASE_SERVICE_ROLE_CLIENT,
+  SupabaseModule
+};

package/dist/database/supabase/supabase.module.d.ts

@@ -0,0 +1,6 @@
+/** DI token for the anon-key Supabase client (respects RLS as the caller). */
+export declare const SUPABASE_ANON_CLIENT: unique symbol;
+/** DI token for the service-role Supabase client (bypasses RLS — server-only use). */
+export declare const SUPABASE_SERVICE_ROLE_CLIENT: unique symbol;
+export declare class SupabaseModule {
+}

package/dist/entities/base-response.dto.d.ts

@@ -0,0 +1,15 @@
+import type { BaseEntity } from './base.entity.js';
+/**
+ * Base class for response DTOs that mirror an entity's public shape.
+ * Extend it, add/omit fields as needed, and reuse `fromEntity()` to map
+ * a domain entity onto the DTO without repeating boilerplate constructors.
+ *
+ * Uses the "polymorphic this" pattern so `fromEntity` returns an instance
+ * of the concrete subclass, not `BaseResponseDto` itself.
+ */
+export declare abstract class BaseResponseDto {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    static fromEntity<TDto extends BaseResponseDto, TEntity extends BaseEntity>(this: new () => TDto, entity: TEntity): TDto;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Base shape every domain entity managed by nestkit must satisfy.
+ * Intentionally not a class (no ORM decorators) — this is a framework-agnostic
+ * contract. Consumers map their own persistence model (row, document, etc.)
+ * onto this shape in their repository adapters.
+ */
+export interface BaseEntity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/entities/index.d.ts

@@ -0,0 +1,3 @@
+export type { BaseEntity } from './base.entity.js';
+export type { SoftDeleteEntity } from './soft-delete.entity.js';
+export { BaseResponseDto } from './base-response.dto.js';

package/dist/entities/index.js

@@ -0,0 +1,7 @@
+import {
+  BaseResponseDto
+} from "../chunk-XX2HPTRU.js";
+import "../chunk-4MGIQFAJ.js";
+export {
+  BaseResponseDto
+};

package/dist/entities/soft-delete.entity.d.ts

@@ -0,0 +1,8 @@
+import type { BaseEntity } from './base.entity.js';
+/**
+ * Entity shape for domains that use soft-delete instead of hard row/document
+ * removal. `deletedAt` is `null` while the entity is active.
+ */
+export interface SoftDeleteEntity extends BaseEntity {
+    deletedAt: Date | null;
+}

package/dist/errors/app.exception.d.ts

@@ -0,0 +1,11 @@
+import { HttpException, type HttpStatus } from '@nestjs/common';
+/**
+ * Base for all domain/application exceptions in nestkit-based services.
+ * Carries a stable machine-readable `code` (independent from the HTTP
+ * status) that clients can branch on, plus optional structured `details`.
+ */
+export declare class AppException extends HttpException {
+    readonly code: string;
+    readonly details?: unknown;
+    constructor(code: string, message: string, status: HttpStatus, details?: unknown);
+}

package/dist/errors/common.exceptions.d.ts

@@ -0,0 +1,16 @@
+import { AppException } from './app.exception.js';
+export declare class NotFoundAppException extends AppException {
+    constructor(message?: string, details?: unknown, code?: string);
+}
+export declare class ConflictAppException extends AppException {
+    constructor(message?: string, details?: unknown, code?: string);
+}
+export declare class ValidationAppException extends AppException {
+    constructor(message?: string, details?: unknown, code?: string);
+}
+export declare class UnauthorizedAppException extends AppException {
+    constructor(message?: string, details?: unknown, code?: string);
+}
+export declare class ForbiddenAppException extends AppException {
+    constructor(message?: string, details?: unknown, code?: string);
+}

package/dist/errors/global-exception.filter.d.ts

@@ -0,0 +1,13 @@
+import { type ArgumentsHost, type ExceptionFilter } from '@nestjs/common';
+/**
+ * Global filter that translates AppException, native Nest HttpException, and
+ * any unhandled error into the standard ApiErrorResponse envelope. Register
+ * with `app.useGlobalFilters(new GlobalExceptionFilter())` (or via
+ * `applyNestKitDefaults`). Never leaks a stack trace to the client — it only
+ * goes to the Nest Logger.
+ */
+export declare class GlobalExceptionFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: unknown, host: ArgumentsHost): void;
+    private resolve;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { AppException } from './app.exception.js';
+export { NotFoundAppException, ConflictAppException, ValidationAppException, UnauthorizedAppException, ForbiddenAppException, } from './common.exceptions.js';
+export { GlobalExceptionFilter } from './global-exception.filter.js';

package/dist/errors/index.js

@@ -0,0 +1,22 @@
+import {
+  ConflictAppException,
+  ForbiddenAppException,
+  NotFoundAppException,
+  UnauthorizedAppException,
+  ValidationAppException
+} from "../chunk-HGJX2GPE.js";
+import {
+  AppException,
+  GlobalExceptionFilter
+} from "../chunk-EQXYK6AL.js";
+import "../chunk-EBO6UKHL.js";
+import "../chunk-4MGIQFAJ.js";
+export {
+  AppException,
+  ConflictAppException,
+  ForbiddenAppException,
+  GlobalExceptionFilter,
+  NotFoundAppException,
+  UnauthorizedAppException,
+  ValidationAppException
+};

package/dist/i18n/i18n.module.d.ts

@@ -0,0 +1,18 @@
+import { type DynamicModule } from '@nestjs/common';
+export interface NestKitI18nOptions {
+    /**
+     * Path to the folder containing per-language JSON namespaces, relative to
+     * the consumer's project root. Files are expected at
+     * `{path}/{lang}/{namespace}.json`. Defaults to `./i18n`.
+     */
+    path?: string;
+    /** Defaults to 'es'. */
+    fallbackLanguage?: string;
+}
+/**
+ * Thin wrapper over nestjs-i18n so consumers don't have to know its
+ * loader/resolver configuration shape — just point it at a folder.
+ */
+export declare class I18nModule {
+    static forRoot(options?: NestKitI18nOptions): DynamicModule;
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,3 @@
+export { I18nModule } from './i18n.module.js';
+export type { NestKitI18nOptions } from './i18n.module.js';
+export { translateOr } from './translate.helper.js';

package/dist/i18n/index.js

@@ -0,0 +1,9 @@
+import {
+  I18nModule,
+  translateOr
+} from "../chunk-IYUUYCP5.js";
+import "../chunk-4MGIQFAJ.js";
+export {
+  I18nModule,
+  translateOr
+};

package/dist/i18n/translate.helper.d.ts

@@ -0,0 +1,7 @@
+import type { I18nService } from 'nestjs-i18n';
+/**
+ * Translates `key` via the given I18nService, falling back to `fallback`
+ * when the key is missing or resolution throws — useful inside exceptions
+ * where a missing translation should never itself become the error.
+ */
+export declare function translateOr(i18n: I18nService, key: string, fallback: string, args?: Record<string, unknown>): string;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './entities/index.js';
+export * from './response/index.js';
+export * from './errors/index.js';
+export * from './tracking/index.js';
+export * from './crud/index.js';
+export * from './database/postgres/index.js';
+export * from './database/supabase/index.js';
+export * from './database/mongo/index.js';
+export * from './i18n/index.js';
+export * from './bootstrap/index.js';