@vritti/api-sdk 0.3.3 → 0.3.5

package/dist/database.js

@@ -0,0 +1,1469 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/database/database.module.ts
+import { Global, Module } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+
+// src/database/constants.ts
+var DATABASE_MODULE_OPTIONS = Symbol("DATABASE_MODULE_OPTIONS");
+
+// src/database/services/primary-database.service.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { Inject, Injectable, InternalServerErrorException, Logger } from "@nestjs/common";
+import { drizzle } from "drizzle-orm/node-postgres";
+
+// src/database/services/rls-aware-pool.ts
+import { Pool } from "pg";
+var RlsAwarePool = class extends Pool {
+  static {
+    __name(this, "RlsAwarePool");
+  }
+  rlsAls;
+  txAls;
+  applyRlsContext;
+  constructor(options) {
+    const { rlsAls, txAls, applyRlsContext, ...poolConfig } = options;
+    super(poolConfig);
+    this.rlsAls = rlsAls;
+    this.txAls = txAls;
+    this.applyRlsContext = applyRlsContext;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: matches pg.Pool.query overload surface
+  query(textOrConfig, values, cb) {
+    if (typeof textOrConfig === "function") {
+      return super.query(textOrConfig);
+    }
+    if (textOrConfig && typeof textOrConfig.submit === "function") {
+      return super.query(textOrConfig, values, cb);
+    }
+    if (typeof values === "function" || typeof cb === "function") {
+      return super.query(textOrConfig, values, cb);
+    }
+    const rls = this.rlsAls.getStore();
+    if (rls === void 0 || this.txAls.getStore() !== void 0 || !this.applyRlsContext) {
+      return super.query(textOrConfig, values);
+    }
+    return this.runWrapped(textOrConfig, values, rls);
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: dispatched from query() overload
+  async runWrapped(textOrConfig, values, rls) {
+    const client = await super.connect();
+    try {
+      await client.query("BEGIN");
+      await this.applyRlsContext(client, rls);
+      const result = await client.query(textOrConfig, values);
+      await client.query("COMMIT");
+      client.release();
+      return result;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      client.release(err);
+      throw err;
+    }
+  }
+};
+
+// src/database/services/primary-database.service.ts
+function _ts_decorate(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var PrimaryDatabaseService = class _PrimaryDatabaseService {
+  static {
+    __name(this, "PrimaryDatabaseService");
+  }
+  options;
+  logger = new Logger(_PrimaryDatabaseService.name);
+  pool = null;
+  db = null;
+  // Per-request RLS context read by RlsAwarePool per query and by runInTransaction at BEGIN.
+  rlsAls = new AsyncLocalStorage();
+  // Active Drizzle transaction client so repository queries participate in the transaction.
+  txAls = new AsyncLocalStorage();
+  constructor(options) {
+    this.options = options;
+  }
+  async onModuleInit() {
+    if (this.options.primaryDb) {
+      await this.initializeDrizzleClient();
+    }
+  }
+  // Initializes connection to primary database using Drizzle
+  async initializeDrizzleClient() {
+    try {
+      const { host, port = 5432, username, password, database, schema, sslMode = "require" } = this.options.primaryDb;
+      this.pool = new RlsAwarePool({
+        host,
+        port,
+        user: username,
+        password,
+        database,
+        max: this.options.maxConnections || 10,
+        ssl: sslMode === "disable" ? false : {
+          rejectUnauthorized: sslMode !== "no-verify"
+        },
+        ...schema && {
+          options: `-csearch_path=${schema}`
+        },
+        rlsAls: this.rlsAls,
+        txAls: this.txAls,
+        applyRlsContext: this.options.applyRlsContext
+      });
+      this.logger.debug(`Relations keys passed to drizzle: [${Object.keys(this.options.drizzleRelations || {}).join(", ")}]`);
+      this.db = drizzle({
+        client: this.pool,
+        relations: this.options.drizzleRelations
+      });
+      await this.pool.query("SELECT 1");
+      this.logger.log(`Connected to primary database (schema: ${schema ?? "public"})`);
+    } catch (error) {
+      this.logger.error("Failed to connect to primary database", error);
+      throw new InternalServerErrorException("Failed to initialize database connection");
+    }
+  }
+  // Returns the active Drizzle client — the pinned tx inside runInTransaction, else the pool-backed one.
+  get drizzleClient() {
+    const pinned = this.txAls.getStore();
+    if (pinned) return pinned;
+    if (!this.db) {
+      throw new Error("Primary database client not initialized");
+    }
+    return this.db;
+  }
+  // Stashes per-request RLS context in AsyncLocalStorage for downstream queries to apply via SET LOCAL.
+  runWithRlsContext(rls, fn) {
+    return this.rlsAls.run(rls, fn);
+  }
+  // Opens a transaction pinning all queries in `fn` to one connection, applying RLS once at BEGIN.
+  async runInTransaction(fn) {
+    const pinned = this.txAls.getStore();
+    if (pinned) {
+      return pinned.transaction(async (sp) => this.txAls.run(sp, fn));
+    }
+    if (!this.db) {
+      throw new Error("Primary database client not initialized");
+    }
+    const rls = this.rlsAls.getStore();
+    const applyRls = this.options.applyRlsContext;
+    return this.db.transaction(async (tx) => {
+      if (rls !== void 0 && applyRls) {
+        const sessionClient = tx?.session?.client;
+        if (sessionClient) {
+          await applyRls(sessionClient, rls);
+        }
+      }
+      return this.txAls.run(tx, fn);
+    });
+  }
+  // Deprecated: prefer runInTransaction. Retained so existing callers keep working until migrated.
+  async runWithPinnedConnection(fn) {
+    return this.runInTransaction(fn);
+  }
+  async onModuleDestroy() {
+    if (this.pool) {
+      await this.pool.end();
+      this.logger.log("Disconnected from primary database");
+    }
+  }
+};
+PrimaryDatabaseService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(DATABASE_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
+  ])
+], PrimaryDatabaseService);
+
+// src/database/database.module.ts
+function _ts_decorate2(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var DatabaseModule = class _DatabaseModule {
+  static {
+    __name(this, "DatabaseModule");
+  }
+  // Configures the database module with a single primary connection
+  static forServer(options) {
+    const asyncProvider = {
+      provide: DATABASE_MODULE_OPTIONS,
+      useFactory: options.useFactory,
+      inject: options.inject || []
+    };
+    return {
+      module: _DatabaseModule,
+      providers: [
+        {
+          provide: Reflector,
+          useClass: Reflector
+        },
+        asyncProvider,
+        PrimaryDatabaseService
+      ],
+      exports: [
+        PrimaryDatabaseService,
+        asyncProvider
+      ]
+    };
+  }
+};
+DatabaseModule = _ts_decorate2([
+  Global(),
+  Module({})
+], DatabaseModule);
+
+// src/database/dto/create-response.dto.ts
+import { ApiProperty } from "@nestjs/swagger";
+function _ts_decorate3(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var CreateResponseDto = class {
+  static {
+    __name(this, "CreateResponseDto");
+  }
+  success;
+  message;
+  data;
+};
+_ts_decorate3([
+  ApiProperty({
+    example: true
+  }),
+  _ts_metadata2("design:type", Boolean)
+], CreateResponseDto.prototype, "success", void 0);
+_ts_decorate3([
+  ApiProperty({
+    example: "Resource created successfully"
+  }),
+  _ts_metadata2("design:type", String)
+], CreateResponseDto.prototype, "message", void 0);
+_ts_decorate3([
+  ApiProperty(),
+  _ts_metadata2("design:type", typeof T === "undefined" ? Object : T)
+], CreateResponseDto.prototype, "data", void 0);
+
+// src/database/dto/cursor-list-response.dto.ts
+import { ApiProperty as ApiProperty2, ApiPropertyOptional } from "@nestjs/swagger";
+function _ts_decorate4(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var CursorListResponseDto = class {
+  static {
+    __name(this, "CursorListResponseDto");
+  }
+  items;
+  nextCursor;
+  hasMore;
+};
+_ts_decorate4([
+  ApiProperty2(),
+  _ts_metadata3("design:type", Array)
+], CursorListResponseDto.prototype, "items", void 0);
+_ts_decorate4([
+  ApiPropertyOptional({
+    nullable: true
+  }),
+  _ts_metadata3("design:type", Object)
+], CursorListResponseDto.prototype, "nextCursor", void 0);
+_ts_decorate4([
+  ApiProperty2(),
+  _ts_metadata3("design:type", Boolean)
+], CursorListResponseDto.prototype, "hasMore", void 0);
+
+// src/database/dto/import-response.dto.ts
+import { ApiProperty as ApiProperty3, ApiPropertyOptional as ApiPropertyOptional2 } from "@nestjs/swagger";
+function _ts_decorate5(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var ValidatedRowDto = class {
+  static {
+    __name(this, "ValidatedRowDto");
+  }
+  index;
+  data;
+  valid;
+  errors;
+};
+_ts_decorate5([
+  ApiProperty3({
+    example: 1
+  }),
+  _ts_metadata4("design:type", Number)
+], ValidatedRowDto.prototype, "index", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: {
+      code: "products",
+      name: "Products"
+    }
+  }),
+  _ts_metadata4("design:type", typeof Record === "undefined" ? Object : Record)
+], ValidatedRowDto.prototype, "data", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: true
+  }),
+  _ts_metadata4("design:type", Boolean)
+], ValidatedRowDto.prototype, "valid", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: [
+      "Code already exists"
+    ]
+  }),
+  _ts_metadata4("design:type", Array)
+], ValidatedRowDto.prototype, "errors", void 0);
+var ImportSummaryDto = class {
+  static {
+    __name(this, "ImportSummaryDto");
+  }
+  total;
+  valid;
+  invalid;
+};
+_ts_decorate5([
+  ApiProperty3({
+    example: 10
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportSummaryDto.prototype, "total", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: 8
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportSummaryDto.prototype, "valid", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: 2
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportSummaryDto.prototype, "invalid", void 0);
+var ImportResponseDto = class {
+  static {
+    __name(this, "ImportResponseDto");
+  }
+  success;
+  message;
+  created;
+  updated;
+  skipped;
+  rows;
+  summary;
+};
+_ts_decorate5([
+  ApiProperty3({
+    example: true
+  }),
+  _ts_metadata4("design:type", Boolean)
+], ImportResponseDto.prototype, "success", void 0);
+_ts_decorate5([
+  ApiProperty3({
+    example: "Import complete."
+  }),
+  _ts_metadata4("design:type", String)
+], ImportResponseDto.prototype, "message", void 0);
+_ts_decorate5([
+  ApiPropertyOptional2({
+    example: 3
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportResponseDto.prototype, "created", void 0);
+_ts_decorate5([
+  ApiPropertyOptional2({
+    example: 2
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportResponseDto.prototype, "updated", void 0);
+_ts_decorate5([
+  ApiPropertyOptional2({
+    example: 1
+  }),
+  _ts_metadata4("design:type", Number)
+], ImportResponseDto.prototype, "skipped", void 0);
+_ts_decorate5([
+  ApiPropertyOptional2({
+    type: [
+      ValidatedRowDto
+    ]
+  }),
+  _ts_metadata4("design:type", Array)
+], ImportResponseDto.prototype, "rows", void 0);
+_ts_decorate5([
+  ApiPropertyOptional2({
+    type: ImportSummaryDto
+  }),
+  _ts_metadata4("design:type", typeof ImportSummaryDto === "undefined" ? Object : ImportSummaryDto)
+], ImportResponseDto.prototype, "summary", void 0);
+
+// src/database/dto/select-options-query.dto.ts
+import { ApiPropertyOptional as ApiPropertyOptional3 } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsIn, IsInt, IsOptional, IsString, Min } from "class-validator";
+function _ts_decorate6(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var SelectOptionsQueryDto = class {
+  static {
+    __name(this, "SelectOptionsQueryDto");
+  }
+  search;
+  limit;
+  offset;
+  values;
+  excludeIds;
+  valueKey;
+  labelKey;
+  descriptionKey;
+  additionalKeys;
+  groupIdKey;
+  orderByKey;
+  orderDirection;
+};
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Search term to filter by label",
+    example: "united"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "search", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Maximum number of results",
+    example: 20,
+    default: 20
+  }),
+  IsOptional(),
+  Type(() => Number),
+  IsInt(),
+  Min(1),
+  _ts_metadata5("design:type", Number)
+], SelectOptionsQueryDto.prototype, "limit", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Number of results to skip",
+    example: 0,
+    default: 0
+  }),
+  IsOptional(),
+  Type(() => Number),
+  IsInt(),
+  Min(0),
+  _ts_metadata5("design:type", Number)
+], SelectOptionsQueryDto.prototype, "offset", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Comma-separated values to fetch specific options",
+    example: "1,2,3"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "values", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Comma-separated IDs to exclude from results (already selected)",
+    example: "5,10"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "excludeIds", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Column name for option value",
+    example: "id",
+    default: "id"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "valueKey", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Column name for option label",
+    example: "name",
+    default: "name"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "labelKey", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Column name for option description",
+    example: "description"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "descriptionKey", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Comma-separated column names to include in option.additionals",
+    example: "locationName,availableQuantity"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "additionalKeys", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Column name for group ID",
+    example: "regionId"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "groupIdKey", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Column name to sort options by",
+    example: "name",
+    default: "name"
+  }),
+  IsOptional(),
+  IsString(),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "orderByKey", void 0);
+_ts_decorate6([
+  ApiPropertyOptional3({
+    description: "Sort direction for options",
+    example: "asc",
+    default: "asc",
+    enum: [
+      "asc",
+      "desc"
+    ]
+  }),
+  IsOptional(),
+  IsString(),
+  IsIn([
+    "asc",
+    "desc"
+  ]),
+  _ts_metadata5("design:type", String)
+], SelectOptionsQueryDto.prototype, "orderDirection", void 0);
+
+// src/database/dto/success-response.dto.ts
+import { ApiProperty as ApiProperty4 } from "@nestjs/swagger";
+import { IsBoolean, IsNotEmpty, IsString as IsString2 } from "class-validator";
+function _ts_decorate7(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var SuccessResponseDto = class {
+  static {
+    __name(this, "SuccessResponseDto");
+  }
+  success;
+  message;
+};
+_ts_decorate7([
+  ApiProperty4({
+    example: true
+  }),
+  IsNotEmpty(),
+  IsBoolean(),
+  _ts_metadata6("design:type", Boolean)
+], SuccessResponseDto.prototype, "success", void 0);
+_ts_decorate7([
+  ApiProperty4({
+    example: "Operation completed successfully"
+  }),
+  IsNotEmpty(),
+  IsString2(),
+  _ts_metadata6("design:type", String)
+], SuccessResponseDto.prototype, "message", void 0);
+
+// src/database/dto/table-response.dto.ts
+import { ApiProperty as ApiProperty5, ApiPropertyOptional as ApiPropertyOptional4 } from "@nestjs/swagger";
+function _ts_decorate8(decorators, target, key, desc3) {
+  var c = arguments.length, r = c < 3 ? target : desc3 === null ? desc3 = Object.getOwnPropertyDescriptor(target, key) : desc3, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc3);
+  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;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var TableResponseDto = class {
+  static {
+    __name(this, "TableResponseDto");
+  }
+  result;
+  count;
+  state;
+  activeViewId;
+};
+_ts_decorate8([
+  ApiProperty5(),
+  _ts_metadata7("design:type", Array)
+], TableResponseDto.prototype, "result", void 0);
+_ts_decorate8([
+  ApiProperty5(),
+  _ts_metadata7("design:type", Number)
+], TableResponseDto.prototype, "count", void 0);
+_ts_decorate8([
+  ApiProperty5(),
+  _ts_metadata7("design:type", typeof TableViewState === "undefined" ? Object : TableViewState)
+], TableResponseDto.prototype, "state", void 0);
+_ts_decorate8([
+  ApiPropertyOptional4({
+    nullable: true
+  }),
+  _ts_metadata7("design:type", Object)
+], TableResponseDto.prototype, "activeViewId", void 0);
+
+// src/database/filter/cursor.codec.ts
+import { createHmac, timingSafeEqual } from "crypto";
+
+// src/exceptions/bad-gateway.exception.ts
+import { HttpStatus } from "@nestjs/common";
+
+// src/exceptions/base-field.exception.ts
+import { HttpException } from "@nestjs/common";
+var HttpProblemException = class extends HttpException {
+  static {
+    __name(this, "HttpProblemException");
+  }
+  constructor(detailOrOptions, httpStatus) {
+    const options = typeof detailOrOptions === "string" ? {
+      detail: detailOrOptions
+    } : detailOrOptions;
+    super({
+      type: options.type ?? "about:blank",
+      label: options.label,
+      detail: options.detail,
+      errors: options.errors ?? []
+    }, httpStatus);
+  }
+};
+
+// src/exceptions/bad-request.exception.ts
+import { HttpStatus as HttpStatus2 } from "@nestjs/common";
+var BadRequestException = class extends HttpProblemException {
+  static {
+    __name(this, "BadRequestException");
+  }
+  constructor(detailOrOptions) {
+    super(detailOrOptions ?? "Bad Request", HttpStatus2.BAD_REQUEST);
+  }
+};
+
+// src/exceptions/conflict.exception.ts
+import { HttpStatus as HttpStatus3 } from "@nestjs/common";
+
+// src/exceptions/forbidden.exception.ts
+import { HttpStatus as HttpStatus4 } from "@nestjs/common";
+
+// src/exceptions/gone.exception.ts
+import { HttpStatus as HttpStatus5 } from "@nestjs/common";
+
+// src/exceptions/internal-server-error.exception.ts
+import { HttpStatus as HttpStatus6 } from "@nestjs/common";
+
+// src/exceptions/invalid-cursor.exception.ts
+var InvalidCursorException = class extends BadRequestException {
+  static {
+    __name(this, "InvalidCursorException");
+  }
+  constructor(detail = "The pagination cursor is invalid.") {
+    super({
+      label: "Invalid cursor",
+      detail
+    });
+  }
+};
+
+// src/exceptions/method-not-allowed.exception.ts
+import { HttpStatus as HttpStatus7 } from "@nestjs/common";
+
+// src/exceptions/not-acceptable.exception.ts
+import { HttpStatus as HttpStatus8 } from "@nestjs/common";
+
+// src/exceptions/not-found.exception.ts
+import { HttpStatus as HttpStatus9 } from "@nestjs/common";
+
+// src/exceptions/not-implemented.exception.ts
+import { HttpStatus as HttpStatus10 } from "@nestjs/common";
+
+// src/exceptions/payload-too-large.exception.ts
+import { HttpStatus as HttpStatus11 } from "@nestjs/common";
+
+// src/exceptions/request-timeout.exception.ts
+import { HttpStatus as HttpStatus12 } from "@nestjs/common";
+
+// src/exceptions/service-unavailable.exception.ts
+import { HttpStatus as HttpStatus13 } from "@nestjs/common";
+
+// src/exceptions/too-many-requests.exception.ts
+import { HttpStatus as HttpStatus14 } from "@nestjs/common";
+
+// src/exceptions/unauthorized.exception.ts
+import { HttpStatus as HttpStatus15 } from "@nestjs/common";
+
+// src/exceptions/unprocessable-entity.exception.ts
+import { HttpStatus as HttpStatus16 } from "@nestjs/common";
+
+// src/exceptions/unsupported-media-type.exception.ts
+import { HttpStatus as HttpStatus17 } from "@nestjs/common";
+
+// src/exceptions/validation.exception.ts
+import { HttpStatus as HttpStatus18 } from "@nestjs/common";
+
+// src/database/filter/cursor.codec.ts
+var CURSOR_SECRET = process.env.KEYSET_CURSOR_SECRET ?? "vritti-dev-insecure-keyset-secret";
+function sign(body) {
+  return createHmac("sha256", CURSOR_SECRET).update(body).digest("base64url");
+}
+__name(sign, "sign");
+var CursorCodec = class {
+  static {
+    __name(this, "CursorCodec");
+  }
+  // Encodes ORDER BY boundary values into a tamper-evident base64url token bound to the sort signature.
+  static encode(values, signature = "") {
+    const serialized = values.map((v) => {
+      if (v instanceof Date) return {
+        __t: "date",
+        v: v.toISOString()
+      };
+      if (v === null || v === void 0) return null;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+      return String(v);
+    });
+    const envelope = {
+      s: signature,
+      v: serialized
+    };
+    const body = Buffer.from(JSON.stringify(envelope), "utf8").toString("base64url");
+    return `${body}.${sign(body)}`;
+  }
+  // Decodes a cursor back into ordered boundary values, throwing InvalidCursorException on any tamper or sort mismatch.
+  static decode(cursor, expectedSignature = "") {
+    const dot = cursor.lastIndexOf(".");
+    if (dot <= 0) throw new InvalidCursorException("Malformed pagination cursor.");
+    const body = cursor.slice(0, dot);
+    const mac = cursor.slice(dot + 1);
+    const macBuf = Buffer.from(mac, "base64url");
+    const expBuf = Buffer.from(sign(body), "base64url");
+    if (macBuf.length !== expBuf.length || !timingSafeEqual(macBuf, expBuf)) {
+      throw new InvalidCursorException("Pagination cursor failed its integrity check.");
+    }
+    let envelope;
+    try {
+      envelope = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    } catch {
+      throw new InvalidCursorException("Pagination cursor could not be parsed.");
+    }
+    if (!envelope || typeof envelope.s !== "string" || !Array.isArray(envelope.v)) {
+      throw new InvalidCursorException("Pagination cursor has an unexpected shape.");
+    }
+    if (envelope.s !== expectedSignature) {
+      throw new InvalidCursorException("Pagination cursor does not match the current sort order.");
+    }
+    return envelope.v.map((v) => {
+      if (v && typeof v === "object" && "__t" in v && v.__t === "date") return new Date(v.v);
+      return v;
+    });
+  }
+};
+
+// src/database/filter/filter.processor.ts
+import { and, asc, desc, eq, gt, gte, ilike, inArray, lt, lte, ne, notIlike, notInArray, or } from "drizzle-orm";
+var FilterProcessor = class {
+  static {
+    __name(this, "FilterProcessor");
+  }
+  // Returns undefined if no conditions (Drizzle accepts undefined as "no WHERE")
+  static buildWhere(filters = [], fieldMap) {
+    const conditions = filters.flatMap((f) => {
+      const def = fieldMap[f.field];
+      if (!def) return [];
+      if ("expression" in def) return Array.isArray(f.value) ? [] : [
+        def.expression(f.value, f.operator)
+      ];
+      const { column: col } = def;
+      const val = f.value;
+      switch (f.operator) {
+        case "equals":
+          if (def.type === "boolean") return [
+            eq(col, val === "true" || val === 1)
+          ];
+          return [
+            eq(col, val)
+          ];
+        case "notEquals":
+          if (def.type === "boolean") return [
+            ne(col, val === "true" || val === 1)
+          ];
+          return [
+            ne(col, val)
+          ];
+        case "contains":
+          return [
+            ilike(col, `%${val}%`)
+          ];
+        case "notContains":
+          return [
+            notIlike(col, `%${val}%`)
+          ];
+        case "gt":
+          return [
+            gt(col, val)
+          ];
+        case "gte":
+          return [
+            gte(col, val)
+          ];
+        case "lt":
+          return [
+            lt(col, val)
+          ];
+        case "lte":
+          return [
+            lte(col, val)
+          ];
+        case "isAnyOf":
+          return [
+            inArray(col, Array.isArray(val) ? val : [
+              String(val)
+            ])
+          ];
+        case "isNotAnyOf":
+          return [
+            notInArray(col, Array.isArray(val) ? val : [
+              String(val)
+            ])
+          ];
+        default:
+          return [];
+      }
+    });
+    return conditions.length ? and(...conditions) : void 0;
+  }
+  // Builds a search WHERE — OR across all string fields when columnId is 'all', otherwise a single ilike
+  static buildSearch(search, fieldMap) {
+    if (!search?.value) return void 0;
+    if (search.columnId === "all") {
+      const conditions = Object.values(fieldMap).filter((def2) => "column" in def2 && def2.type === "string").map((def2) => ilike(def2.column, `%${search.value}%`));
+      return conditions.length ? or(...conditions) : void 0;
+    }
+    const def = fieldMap[search.columnId];
+    if (!def || !("column" in def)) return void 0;
+    return ilike(def.column, `%${search.value}%`);
+  }
+  // Maps each SortCondition to an asc/desc SQL expression
+  static buildOrderBy(sort = [], fieldMap) {
+    return sort.flatMap((s) => {
+      const def = fieldMap[s.field];
+      if (!def || !("column" in def)) return [];
+      return [
+        s.direction === "asc" ? asc(def.column) : desc(def.column)
+      ];
+    });
+  }
+};
+
+// src/database/filter/filter.types.ts
+var FilterOperators = {
+  EQUALS: "equals",
+  NOT_EQUALS: "notEquals",
+  CONTAINS: "contains",
+  NOT_CONTAINS: "notContains",
+  GT: "gt",
+  GTE: "gte",
+  LT: "lt",
+  LTE: "lte",
+  IS_ANY_OF: "isAnyOf",
+  IS_NOT_ANY_OF: "isNotAnyOf"
+};
+
+// src/database/filter/keyset.processor.ts
+import { and as and2, eq as eq2, gt as gt2, isNotNull, isNull, lt as lt2, or as or2, sql } from "drizzle-orm";
+var MAX_PAGE_SIZE = 100;
+function keysetSignature(entries) {
+  return entries.map((e) => `${e.key}:${e.direction}`).join(",");
+}
+__name(keysetSignature, "keysetSignature");
+var KeysetProcessor = class _KeysetProcessor {
+  static {
+    __name(this, "KeysetProcessor");
+  }
+  // Builds the "after this row" predicate for keyset pagination.
+  static buildAfter(orderBy, values) {
+    const first = orderBy[0];
+    if (!first) return sql`true`;
+    const uniform = orderBy.every((o) => o.direction === first.direction);
+    const anyNullable = orderBy.some((o) => o.nulls !== void 0);
+    if (uniform && !anyNullable && orderBy.length >= 2) {
+      return _KeysetProcessor.buildRowValue(orderBy, values, first.direction);
+    }
+    return _KeysetProcessor.buildOrExpansion(orderBy, values);
+  }
+  // (c1, c2, …) > (v1, v2, …) for asc, < for desc. Correct only for uniform direction, no NULLs.
+  static buildRowValue(orderBy, values, direction) {
+    const cols = sql.join(orderBy.map((o) => sql`${o.column}`), sql`, `);
+    const vals = sql.join(values.map((v) => sql`${v}`), sql`, `);
+    const op = direction === "asc" ? sql`>` : sql`<`;
+    return sql`(${cols}) ${op} (${vals})`;
+  }
+  // Lexicographic OR-expansion, NULL-aware per column when a `nulls` placement is declared.
+  static buildOrExpansion(orderBy, values) {
+    const groups = [];
+    for (let i = 0; i < orderBy.length; i++) {
+      const current = orderBy[i];
+      if (!current) continue;
+      const conditions = [];
+      for (let j = 0; j < i; j++) {
+        const prior = orderBy[j];
+        if (prior) conditions.push(_KeysetProcessor.tie(prior.column, values[j]));
+      }
+      conditions.push(_KeysetProcessor.strictlyAfter(current, values[i]));
+      const group = conditions.length === 1 ? conditions[0] : and2(...conditions);
+      if (group) groups.push(group);
+    }
+    const firstGroup = groups[0];
+    if (groups.length === 1 && firstGroup) return firstGroup;
+    return or2(...groups);
+  }
+  // Tie on an earlier column: match its boundary value (NULL-safe).
+  static tie(column, value) {
+    return value === null || value === void 0 ? isNull(column) : eq2(column, value);
+  }
+  // Strictly past the boundary on this column, respecting direction and NULL placement.
+  static strictlyAfter(o, value) {
+    if (o.nulls === void 0) {
+      return o.direction === "asc" ? gt2(o.column, value) : lt2(o.column, value);
+    }
+    const nullsLast = o.nulls === "last";
+    if (value === null || value === void 0) {
+      return nullsLast ? sql`false` : isNotNull(o.column);
+    }
+    const cmp = o.direction === "asc" ? gt2(o.column, value) : lt2(o.column, value);
+    return nullsLast ? or2(cmp, isNull(o.column)) : cmp;
+  }
+};
+
+// src/database/repositories/primary-base.repository.ts
+import { Logger as Logger2 } from "@nestjs/common";
+import { and as and3, asc as asc2, desc as desc2, eq as eq3, getTableName, getViewName, ilike as ilike2, inArray as inArray2, is, notInArray as notInArray2, sql as sql2 } from "drizzle-orm";
+import { PgViewBase } from "drizzle-orm/pg-core/view-base";
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+__name(snakeToCamel, "snakeToCamel");
+var PrimaryBaseRepository = class {
+  static {
+    __name(this, "PrimaryBaseRepository");
+  }
+  database;
+  table;
+  logger;
+  sequence;
+  tableName;
+  isView;
+  get db() {
+    return this.database.drizzleClient;
+  }
+  get model() {
+    if (this.isView) {
+      throw new Error(`${this.constructor.name}: relational queries (.model) are not supported on the view '${this.tableName}'. Use findForSelect / findAllAndCount instead.`);
+    }
+    const query = this.database.drizzleClient.query;
+    const queryKeys = Object.keys(query || {});
+    this.logger.debug(`Looking for '${this.tableName}' in query keys: [${queryKeys.join(", ")}]`);
+    const model = query[this.tableName];
+    if (!model) {
+      this.logger.error(`Table '${this.tableName}' not found in query object. Available: [${queryKeys.join(", ")}]`);
+    }
+    return model;
+  }
+  constructor(database, table, options) {
+    this.database = database;
+    this.table = table;
+    this.isView = is(table, PgViewBase);
+    const dbTableName = this.isView ? getViewName(table) : getTableName(table);
+    this.tableName = snakeToCamel(dbTableName);
+    this.sequence = options?.sequence;
+    this.logger = new Logger2(this.constructor.name);
+    this.logger.debug(`Initialized ${this.constructor.name}`);
+    this.logger.debug(`Table name: '${dbTableName}' -> query key: '${this.tableName}'`);
+  }
+  // Returns next value from configured sequence, or an explicitly passed sequence
+  async nextSequenceValue(sequence) {
+    const resolvedSequence = sequence ?? this.sequence;
+    if (!resolvedSequence) {
+      throw new Error(`${this.constructor.name}: sequence is required for nextSequenceValue`);
+    }
+    const sequenceName = resolvedSequence.schema ? `${resolvedSequence.schema}.${resolvedSequence.seqName}` : resolvedSequence.seqName;
+    const result = await this.db.execute(sql2`select nextval(${sequenceName}::regclass) as sequence_value`);
+    const rows = result.rows ?? [];
+    return Number(rows[0]?.sequence_value ?? 1);
+  }
+  // Creates a new record and returns it
+  async create(data, tx) {
+    this.logger.log("Creating record");
+    const db = tx ?? this.db;
+    const results = await db.insert(this.table).values(data).returning();
+    const record = results[0];
+    if (!record) throw new Error(`${this.tableName}: database operation returned no record`);
+    return record;
+  }
+  // Finds a single record by primary key ID
+  async findById(id) {
+    this.logger.debug(`Finding record by ID: ${id}`);
+    return this.model.findFirst({
+      where: {
+        id
+      }
+    });
+  }
+  // Finds a single record matching the given where filter
+  async findOne(where) {
+    this.logger.debug("Finding record with custom query");
+    return this.model.findFirst({
+      where
+    });
+  }
+  // Finds multiple records with optional filtering, ordering, and pagination
+  async findMany(options) {
+    this.logger.debug("Finding multiple records");
+    return this.model.findMany(options);
+  }
+  // Builds a select query with optional custom fields, joins, filter, grouping, ordering, and pagination
+  buildSelectQuery(options) {
+    let query = (options?.select ? this.db.select(options.select).from(this.table) : this.db.select().from(this.table)).$dynamic();
+    if (options?.leftJoin) {
+      query = query.leftJoin(options.leftJoin.table, options.leftJoin.on);
+    }
+    if (options?.leftJoins) {
+      for (const join of options.leftJoins) {
+        query = query.leftJoin(join.table, join.on);
+      }
+    }
+    if (options?.where) {
+      query = query.where(options.where);
+    }
+    if (options?.groupBy?.length) {
+      query = query.groupBy(...options.groupBy);
+    }
+    if (options?.orderBy?.length) {
+      query = query.orderBy(...options.orderBy);
+    }
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    return query;
+  }
+  // Returns paginated result and total count, with optional custom select, LEFT JOINs, GROUP BY, and ordering
+  async findAllAndCount(options) {
+    let countResultPromise;
+    if (options?.groupBy?.length) {
+      let subq = this.db.select({
+        _: sql2`1`
+      }).from(this.table).$dynamic();
+      if (options.leftJoin) {
+        subq = subq.leftJoin(options.leftJoin.table, options.leftJoin.on);
+      }
+      if (options.leftJoins) {
+        for (const join of options.leftJoins) {
+          subq = subq.leftJoin(join.table, join.on);
+        }
+      }
+      if (options.where) {
+        subq = subq.where(options.where);
+      }
+      subq = subq.groupBy(...options.groupBy);
+      const named = subq.as("_count_subq");
+      countResultPromise = this.db.select({
+        count: sql2`count(*)::int`
+      }).from(named);
+    } else {
+      let countQuery = this.db.select({
+        count: sql2`count(*)::int`
+      }).from(this.table).$dynamic();
+      if (options?.leftJoin) {
+        countQuery = countQuery.leftJoin(options.leftJoin.table, options.leftJoin.on);
+      }
+      if (options?.leftJoins) {
+        for (const join of options.leftJoins) {
+          countQuery = countQuery.leftJoin(join.table, join.on);
+        }
+      }
+      if (options?.where) {
+        countQuery = countQuery.where(options.where);
+      }
+      countResultPromise = countQuery;
+    }
+    const [countResult, result] = await Promise.all([
+      countResultPromise,
+      this.buildSelectQuery(options)
+    ]);
+    return {
+      result,
+      count: countResult[0].count
+    };
+  }
+  // Fetches limit+1 rows for keyset pagination and trims, returning rows plus hasMore.
+  async findKeyset(options) {
+    const limit = Math.min(Math.max(1, Math.trunc(options.limit) || 1), MAX_PAGE_SIZE);
+    const rows = await this.buildSelectQuery({
+      ...options,
+      limit: limit + 1
+    });
+    const hasMore = rows.length > limit;
+    return {
+      rows: hasMore ? rows.slice(0, limit) : rows,
+      hasMore
+    };
+  }
+  // Updates a record by ID and returns the updated record
+  async update(id, data, tx) {
+    this.logger.log(`Updating record with ID: ${id}`);
+    const db = tx ?? this.db;
+    const idColumn = this.table.id;
+    if (!idColumn) throw new Error(`Table '${this.tableName}' has no 'id' column`);
+    const results = await db.update(this.table).set(data).where(eq3(idColumn, id)).returning();
+    const record = results[0];
+    if (!record) throw new Error(`${this.tableName}: database operation returned no record`);
+    return record;
+  }
+  // Updates all records matching the SQL condition and returns the affected count
+  async updateMany(where, data, tx) {
+    this.logger.log("Updating multiple records");
+    const db = tx ?? this.db;
+    const result = await db.update(this.table).set(data).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
+  }
+  // Deletes a record by ID and returns the deleted record
+  async delete(id, tx) {
+    this.logger.log(`Deleting record with ID: ${id}`);
+    const db = tx ?? this.db;
+    const idColumn = this.table.id;
+    if (!idColumn) throw new Error(`Table '${this.tableName}' has no 'id' column`);
+    const results = await db.delete(this.table).where(eq3(idColumn, id)).returning();
+    const record = results[0];
+    if (!record) throw new Error(`${this.tableName}: database operation returned no record`);
+    return record;
+  }
+  // Deletes all records matching the SQL condition and returns the affected count
+  async deleteMany(where, tx) {
+    this.logger.log("Deleting multiple records");
+    const db = tx ?? this.db;
+    const result = await db.delete(this.table).where(where);
+    return {
+      count: result.rowCount ?? 0
+    };
+  }
+  // Counts records matching the optional SQL condition
+  async count(where) {
+    this.logger.debug("Counting records");
+    let query = this.db.select({
+      count: sql2`count(*)::int`
+    }).from(this.table).$dynamic();
+    if (where) {
+      query = query.where(where);
+    }
+    const results = await query;
+    return results[0].count;
+  }
+  // Returns true if at least one record matches the SQL condition
+  async exists(where) {
+    const count = await this.count(where);
+    return count > 0;
+  }
+  // Executes the callback within a database transaction, applying the ALS RLS context once at BEGIN.
+  async transaction(callback) {
+    return this.database.runInTransaction(async () => callback(this.database.drizzleClient));
+  }
+  // Finds records formatted as select dropdown options with optional search, pagination, and grouping
+  async findForSelect(config) {
+    this.logger.debug("Finding records for select dropdown");
+    const selectFn = config.distinct ? this.db.selectDistinct.bind(this.db) : this.db.select.bind(this.db);
+    const parsedValues = typeof config.values === "string" ? config.values.split(",").map((v) => v.trim()).filter(Boolean) : config.values;
+    const parsedExcludeIds = typeof config.excludeIds === "string" ? config.excludeIds.split(",").map((v) => v.trim()).filter(Boolean) : config.excludeIds ?? [];
+    const tableColumns = this.table;
+    const joinTables = config.joins?.map((join) => join.table) ?? [];
+    const resolveColumn = /* @__PURE__ */ __name((key) => {
+      if (tableColumns[key]) return tableColumns[key];
+      for (const joinColumns of joinTables) {
+        if (joinColumns[key]) return joinColumns[key];
+      }
+      return void 0;
+    }, "resolveColumn");
+    const valueCol = resolveColumn(config.value);
+    if (!valueCol) throw new Error(`Column '${config.value}' not found in table '${this.tableName}' or its joins`);
+    const labelCol = resolveColumn(config.label);
+    if (!labelCol) throw new Error(`Column '${config.label}' not found in table '${this.tableName}' or its joins`);
+    const descriptionCol = config.description ? resolveColumn(config.description) : void 0;
+    const parseKeys = /* @__PURE__ */ __name((input) => {
+      if (!input) return [];
+      const values = Array.isArray(input) ? input : input.split(",");
+      return values.map((v) => v.trim()).filter(Boolean);
+    }, "parseKeys");
+    const additionalKeys = parseKeys(config.additionalKeys);
+    const additionalEntries = [
+      ...additionalKeys.map((key) => ({
+        key,
+        expr: resolveColumn(key)
+      })).filter((e) => Boolean(e.expr)),
+      ...Object.entries(config.additionalExpressions ?? {}).map(([key, expr]) => ({
+        key,
+        expr
+      }))
+    ];
+    const additionalAlias = /* @__PURE__ */ __name((key) => `__additional_${key}`, "additionalAlias");
+    if (parsedValues && parsedValues.length > 0) {
+      const selectCols = {
+        value: valueCol,
+        label: labelCol
+      };
+      if (descriptionCol) selectCols.description = descriptionCol;
+      if (config.groupIdKey) {
+        const groupIdCol = resolveColumn(config.groupIdKey);
+        if (groupIdCol) selectCols.groupId = groupIdCol;
+      }
+      for (const entry of additionalEntries) {
+        selectCols[additionalAlias(entry.key)] = entry.expr;
+      }
+      let valuesQuery = selectFn(selectCols).from(this.table).$dynamic();
+      if (config.joins) {
+        for (const join of config.joins) {
+          if (join.type === "inner") {
+            valuesQuery = valuesQuery.innerJoin(join.table, join.on);
+          } else {
+            valuesQuery = valuesQuery.leftJoin(join.table, join.on);
+          }
+        }
+      }
+      const rows2 = await valuesQuery.where(inArray2(valueCol, parsedValues));
+      return {
+        options: rows2.map((row) => ({
+          value: row.value,
+          label: String(row.label),
+          ...descriptionCol && row.description != null ? {
+            description: String(row.description)
+          } : {},
+          ...config.groupIdKey && row.groupId != null ? {
+            groupId: row.groupId
+          } : {},
+          ...additionalEntries.length > 0 ? {
+            additionals: additionalEntries.reduce((acc, entry) => {
+              const value = row[additionalAlias(entry.key)];
+              if (value !== void 0) {
+                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+                  acc[entry.key] = value;
+                } else {
+                  acc[entry.key] = String(value);
+                }
+              }
+              return acc;
+            }, {})
+          } : {}
+        })),
+        hasMore: false,
+        ...config.groups ? {
+          groups: config.groups
+        } : {}
+      };
+    }
+    const selectFields = {
+      value: valueCol,
+      label: labelCol,
+      totalCount: sql2`count(*) over()`.mapWith(Number)
+    };
+    if (descriptionCol) selectFields.description = descriptionCol;
+    if (config.groupIdKey) {
+      const groupIdCol = resolveColumn(config.groupIdKey);
+      if (groupIdCol) selectFields.groupId = groupIdCol;
+    }
+    for (const entry of additionalEntries) {
+      selectFields[additionalAlias(entry.key)] = entry.expr;
+    }
+    const conditions = [];
+    if (config.search) {
+      conditions.push(ilike2(labelCol, `%${config.search}%`));
+    }
+    if (parsedExcludeIds.length > 0) {
+      conditions.push(notInArray2(valueCol, parsedExcludeIds));
+    }
+    if (config.where) {
+      for (const [field, val] of Object.entries(config.where)) {
+        const column = tableColumns[field];
+        if (column) {
+          conditions.push(eq3(column, val));
+        }
+      }
+    }
+    if (config.conditions) {
+      conditions.push(...config.conditions);
+    }
+    const orderByKey = config.orderByKey || (config.orderBy ? Object.keys(config.orderBy)[0] : void 0);
+    const orderDirection = config.orderDirection || (config.orderBy ? Object.values(config.orderBy)[0] : void 0);
+    const orderByCol = orderByKey ? tableColumns[orderByKey] ?? labelCol : labelCol;
+    const limit = Number(config.limit) || 20;
+    const offset = Number(config.offset) || 0;
+    let query = selectFn(selectFields).from(this.table).$dynamic();
+    if (config.joins) {
+      for (const join of config.joins) {
+        if (join.type === "inner") {
+          query = query.innerJoin(join.table, join.on);
+        } else {
+          query = query.leftJoin(join.table, join.on);
+        }
+      }
+    }
+    if (conditions.length > 0) {
+      query = query.where(conditions.length === 1 ? conditions[0] : and3(...conditions));
+    }
+    const orderClauses = [];
+    if (config.groupIdKey) {
+      const groupIdCol = resolveColumn(config.groupIdKey);
+      if (groupIdCol) orderClauses.push(asc2(groupIdCol));
+    }
+    orderClauses.push(orderDirection === "desc" ? desc2(orderByCol) : asc2(orderByCol));
+    query = query.orderBy(...orderClauses).limit(limit).offset(offset);
+    const rows = await query;
+    const totalCount = rows.length > 0 ? rows[0].totalCount : 0;
+    const options = rows.map((row) => ({
+      value: row.value,
+      label: String(row.label),
+      ...descriptionCol && row.description != null ? {
+        description: String(row.description)
+      } : {},
+      ...config.groupIdKey && row.groupId != null ? {
+        groupId: row.groupId
+      } : {},
+      ...additionalEntries.length > 0 ? {
+        additionals: additionalEntries.reduce((acc, entry) => {
+          const value = row[additionalAlias(entry.key)];
+          if (value !== void 0) {
+            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+              acc[entry.key] = value;
+            } else {
+              acc[entry.key] = String(value);
+            }
+          }
+          return acc;
+        }, {})
+      } : {}
+    }));
+    let resolvedGroups = config.groups;
+    if (config.groupTable && config.groupIdKey) {
+      const groupTableColumns = config.groupTable;
+      const groupIdKey = config.groupTableIdKey ?? "id";
+      const groupNameKey = config.groupLabelKey ?? "name";
+      const groupIdCol = groupTableColumns[groupIdKey];
+      if (!groupIdCol) throw new Error(`Column '${groupIdKey}' not found in group table`);
+      const groupNameCol = groupTableColumns[groupNameKey];
+      if (!groupNameCol) throw new Error(`Column '${groupNameKey}' not found in group table`);
+      const groupRows = await this.db.select({
+        id: groupIdCol,
+        name: groupNameCol
+      }).from(config.groupTable).orderBy(asc2(groupNameCol));
+      resolvedGroups = groupRows.map((r) => ({
+        id: r.id,
+        name: String(r.name)
+      }));
+    }
+    return {
+      options,
+      hasMore: offset + limit < totalCount,
+      totalCount,
+      ...resolvedGroups ? {
+        groups: resolvedGroups
+      } : {}
+    };
+  }
+};
+export {
+  CreateResponseDto,
+  CursorCodec,
+  CursorListResponseDto,
+  DatabaseModule,
+  FilterOperators,
+  FilterProcessor,
+  ImportResponseDto,
+  ImportSummaryDto,
+  KeysetProcessor,
+  MAX_PAGE_SIZE,
+  PrimaryBaseRepository,
+  PrimaryDatabaseService,
+  SelectOptionsQueryDto,
+  SuccessResponseDto,
+  TableResponseDto,
+  ValidatedRowDto,
+  keysetSignature
+};
+//# sourceMappingURL=database.js.map