@vritti/api-sdk 0.1.0 → 0.1.1

package/dist/index.d.cts

@@ -151,11 +151,17 @@ interface DatabaseModuleOptions {
      */
     primaryDb: PrimaryDbConfig;
     /**
-     * Drizzle schema object containing all tables and relations
+     * Drizzle schema object containing all tables
      * Import your schema from db/schema/index.ts and pass it here
      * @example import * as schema from '@/db/schema'
      */
     drizzleSchema: RegisteredSchema;
+    /**
+     * Drizzle relations object from defineRelations()
+     * Required for relational queries (db.query.*.findFirst/findMany)
+     * @example import { relations } from '@/db/schema'
+     */
+    drizzleRelations?: Record<string, any>;
     /**
      * Connection cache TTL in milliseconds
      * Idle connections will be closed after this period
@@ -556,22 +562,46 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
 }
 
 /**
- * Type-safe wrapper for Drizzle's RelationalQueryBuilder.
+ * Drizzle ORM v2 object-based where filter type.
+ * Supports simple equality, operators, AND/OR/NOT, and RAW SQL.
+ *
+ * @example
+ * ```typescript
+ * // Simple equality
+ * { email: 'user@example.com' }
+ *
+ * // With operators
+ * { age: { gt: 18, lt: 65 } }
+ *
+ * // AND/OR combinations
+ * { AND: [{ status: 'ACTIVE' }, { age: { gte: 18 } }] }
+ *
+ * // RAW SQL expression
+ * { RAW: (table) => sql`${table.email} ILIKE '%@gmail.com'` }
+ * ```
+ */
+type RelationsWhereFilter = Record<string, any>;
+/**
+ * Type-safe wrapper for Drizzle's RelationalQueryBuilder (v2 API).
  * This interface matches the method signatures of RelationalQueryBuilder
  * but properly binds the TSelect generic for type safety.
  *
  * We use this instead of RelationalQueryBuilder directly because
  * TypeScript cannot infer TSelect from the generic base repository context.
+ *
+ * @remarks
+ * Drizzle ORM v2 uses object-based `where` filters instead of SQL expressions.
+ * See: https://orm.drizzle.team/docs/relations-v1-v2
  */
 interface TypedRelationalQueryBuilder<TSelect> {
     findFirst(config?: {
-        where?: SQL;
+        where?: RelationsWhereFilter;
         with?: Record<string, unknown>;
         columns?: Record<string, boolean>;
     }): Promise<TSelect | undefined>;
     findMany(config?: {
-        where?: SQL;
-        orderBy?: SQL;
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
         limit?: number;
         offset?: number;
         with?: Record<string, unknown>;
@@ -610,17 +640,17 @@ interface TypedRelationalQueryBuilder<TSelect> {
  *     super(database, users);
  *   }
  *
- *   // Use Prisma-like relational query syntax (recommended)
+ *   // Use Drizzle v2 object-based where syntax (recommended)
  *   async findByEmail(email: string): Promise<User | undefined> {
  *     return this.model.findFirst({
- *       where: eq(users.email, email),
+ *       where: { email },
  *     });
  *   }
  *
- *   // Use Prisma-like with relations
+ *   // With relations
  *   async findWithRelations(id: string): Promise<User | undefined> {
  *     return this.model.findFirst({
- *       where: eq(users.id, id),
+ *       where: { id },
  *       with: { posts: true, profile: true }
  *     });
  *   }
@@ -643,15 +673,15 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
      */
     protected get db(): TypedDrizzleClient;
     /**
-     * Model query API for THIS repository's table (Prisma-like syntax)
+     * Model query API for THIS repository's table (Drizzle v2 relational queries)
      * Scoped to only the table this repository manages.
      * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
      *
      * @example
      * ```typescript
-     * // Use relational queries with type safety
+     * // Use relational queries with v2 object-based where syntax
      * const user = await this.model.findFirst({
-     *   where: eq(users.id, id),
+     *   where: { id },
      *   with: { posts: true, profile: true }
      * });
      * ```
@@ -701,43 +731,60 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
      */
     findById(id: string): Promise<TSelect | undefined>;
     /**
-     * Find a single record with custom where clause
+     * Find a single record with custom where clause (Drizzle v2 object-based syntax)
      *
-     * @param where - SQL condition
+     * @param where - Object-based filter condition
      * @returns Promise resolving to the record or undefined if not found
      *
      * @example
      * ```typescript
-     * import { eq } from 'drizzle-orm';
-     * const user = await userRepository.findOne(eq(users.email, 'user@example.com'));
+     * // Simple equality
+     * const user = await userRepository.findOne({ email: 'user@example.com' });
+     *
+     * // With operators
+     * const user = await userRepository.findOne({ age: { gte: 18 } });
+     *
+     * // Multiple conditions (AND)
+     * const user = await userRepository.findOne({
+     *   email: 'user@example.com',
+     *   status: 'ACTIVE'
+     * });
      * ```
      */
-    findOne(where: SQL): Promise<TSelect | undefined>;
+    findOne(where: RelationsWhereFilter): Promise<TSelect | undefined>;
     /**
-     * Find multiple records
+     * Find multiple records (Drizzle v2 object-based syntax)
      *
      * @param options - Query options (where, orderBy, limit, offset)
      * @returns Promise resolving to an array of records
      *
      * @example
      * ```typescript
-     * import { eq, desc } from 'drizzle-orm';
-     *
      * // Find all users
      * const users = await userRepository.findMany();
      *
-     * // Find with filtering and pagination
+     * // Find with filtering and pagination (v2 object syntax)
      * const users = await userRepository.findMany({
-     *   where: eq(users.accountStatus, 'ACTIVE'),
-     *   orderBy: desc(users.createdAt),
+     *   where: { accountStatus: 'ACTIVE' },
+     *   orderBy: { createdAt: 'desc' },
      *   limit: 10,
      *   offset: 0
      * });
+     *
+     * // Multiple conditions
+     * const users = await userRepository.findMany({
+     *   where: {
+     *     AND: [
+     *       { status: 'ACTIVE' },
+     *       { age: { gte: 18 } }
+     *     ]
+     *   }
+     * });
      * ```
      */
     findMany(options?: {
-        where?: SQL;
-        orderBy?: SQL;
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
         limit?: number;
         offset?: number;
     }): Promise<TSelect[]>;

package/dist/index.d.ts

@@ -151,11 +151,17 @@ interface DatabaseModuleOptions {
      */
     primaryDb: PrimaryDbConfig;
     /**
-     * Drizzle schema object containing all tables and relations
+     * Drizzle schema object containing all tables
      * Import your schema from db/schema/index.ts and pass it here
      * @example import * as schema from '@/db/schema'
      */
     drizzleSchema: RegisteredSchema;
+    /**
+     * Drizzle relations object from defineRelations()
+     * Required for relational queries (db.query.*.findFirst/findMany)
+     * @example import { relations } from '@/db/schema'
+     */
+    drizzleRelations?: Record<string, any>;
     /**
      * Connection cache TTL in milliseconds
      * Idle connections will be closed after this period
@@ -556,22 +562,46 @@ declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
 }
 
 /**
- * Type-safe wrapper for Drizzle's RelationalQueryBuilder.
+ * Drizzle ORM v2 object-based where filter type.
+ * Supports simple equality, operators, AND/OR/NOT, and RAW SQL.
+ *
+ * @example
+ * ```typescript
+ * // Simple equality
+ * { email: 'user@example.com' }
+ *
+ * // With operators
+ * { age: { gt: 18, lt: 65 } }
+ *
+ * // AND/OR combinations
+ * { AND: [{ status: 'ACTIVE' }, { age: { gte: 18 } }] }
+ *
+ * // RAW SQL expression
+ * { RAW: (table) => sql`${table.email} ILIKE '%@gmail.com'` }
+ * ```
+ */
+type RelationsWhereFilter = Record<string, any>;
+/**
+ * Type-safe wrapper for Drizzle's RelationalQueryBuilder (v2 API).
  * This interface matches the method signatures of RelationalQueryBuilder
  * but properly binds the TSelect generic for type safety.
  *
  * We use this instead of RelationalQueryBuilder directly because
  * TypeScript cannot infer TSelect from the generic base repository context.
+ *
+ * @remarks
+ * Drizzle ORM v2 uses object-based `where` filters instead of SQL expressions.
+ * See: https://orm.drizzle.team/docs/relations-v1-v2
  */
 interface TypedRelationalQueryBuilder<TSelect> {
     findFirst(config?: {
-        where?: SQL;
+        where?: RelationsWhereFilter;
         with?: Record<string, unknown>;
         columns?: Record<string, boolean>;
     }): Promise<TSelect | undefined>;
     findMany(config?: {
-        where?: SQL;
-        orderBy?: SQL;
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
         limit?: number;
         offset?: number;
         with?: Record<string, unknown>;
@@ -610,17 +640,17 @@ interface TypedRelationalQueryBuilder<TSelect> {
  *     super(database, users);
  *   }
  *
- *   // Use Prisma-like relational query syntax (recommended)
+ *   // Use Drizzle v2 object-based where syntax (recommended)
  *   async findByEmail(email: string): Promise<User | undefined> {
  *     return this.model.findFirst({
- *       where: eq(users.email, email),
+ *       where: { email },
  *     });
  *   }
  *
- *   // Use Prisma-like with relations
+ *   // With relations
  *   async findWithRelations(id: string): Promise<User | undefined> {
  *     return this.model.findFirst({
- *       where: eq(users.id, id),
+ *       where: { id },
  *       with: { posts: true, profile: true }
  *     });
  *   }
@@ -643,15 +673,15 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
      */
     protected get db(): TypedDrizzleClient;
     /**
-     * Model query API for THIS repository's table (Prisma-like syntax)
+     * Model query API for THIS repository's table (Drizzle v2 relational queries)
      * Scoped to only the table this repository manages.
      * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
      *
      * @example
      * ```typescript
-     * // Use relational queries with type safety
+     * // Use relational queries with v2 object-based where syntax
      * const user = await this.model.findFirst({
-     *   where: eq(users.id, id),
+     *   where: { id },
      *   with: { posts: true, profile: true }
      * });
      * ```
@@ -701,43 +731,60 @@ declare abstract class PrimaryBaseRepository<TTable extends PgTable, TInsert = I
      */
     findById(id: string): Promise<TSelect | undefined>;
     /**
-     * Find a single record with custom where clause
+     * Find a single record with custom where clause (Drizzle v2 object-based syntax)
      *
-     * @param where - SQL condition
+     * @param where - Object-based filter condition
      * @returns Promise resolving to the record or undefined if not found
      *
      * @example
      * ```typescript
-     * import { eq } from 'drizzle-orm';
-     * const user = await userRepository.findOne(eq(users.email, 'user@example.com'));
+     * // Simple equality
+     * const user = await userRepository.findOne({ email: 'user@example.com' });
+     *
+     * // With operators
+     * const user = await userRepository.findOne({ age: { gte: 18 } });
+     *
+     * // Multiple conditions (AND)
+     * const user = await userRepository.findOne({
+     *   email: 'user@example.com',
+     *   status: 'ACTIVE'
+     * });
      * ```
      */
-    findOne(where: SQL): Promise<TSelect | undefined>;
+    findOne(where: RelationsWhereFilter): Promise<TSelect | undefined>;
     /**
-     * Find multiple records
+     * Find multiple records (Drizzle v2 object-based syntax)
      *
      * @param options - Query options (where, orderBy, limit, offset)
      * @returns Promise resolving to an array of records
      *
      * @example
      * ```typescript
-     * import { eq, desc } from 'drizzle-orm';
-     *
      * // Find all users
      * const users = await userRepository.findMany();
      *
-     * // Find with filtering and pagination
+     * // Find with filtering and pagination (v2 object syntax)
      * const users = await userRepository.findMany({
-     *   where: eq(users.accountStatus, 'ACTIVE'),
-     *   orderBy: desc(users.createdAt),
+     *   where: { accountStatus: 'ACTIVE' },
+     *   orderBy: { createdAt: 'desc' },
      *   limit: 10,
      *   offset: 0
      * });
+     *
+     * // Multiple conditions
+     * const users = await userRepository.findMany({
+     *   where: {
+     *     AND: [
+     *       { status: 'ACTIVE' },
+     *       { age: { gte: 18 } }
+     *     ]
+     *   }
+     * });
      * ```
      */
     findMany(options?: {
-        where?: SQL;
-        orderBy?: SQL;
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
         limit?: number;
         offset?: number;
     }): Promise<TSelect[]>;

package/dist/index.js

@@ -201,10 +201,14 @@ var PrimaryDatabaseService = class _PrimaryDatabaseService {
         connectionString: databaseUrl,
         max: this.options.maxConnections || 10
       });
+      this.logger.debug(`Schema keys passed to drizzle: [${Object.keys(this.options.drizzleSchema || {}).join(", ")}]`);
+      this.logger.debug(`Relations keys passed to drizzle: [${Object.keys(this.options.drizzleRelations || {}).join(", ")}]`);
       this.db = drizzle({
         client: this.pool,
-        schema: this.options.drizzleSchema
+        schema: this.options.drizzleSchema,
+        relations: this.options.drizzleRelations
       });
+      this.logger.debug(`Drizzle query keys after init: [${Object.keys(this.db.query || {}).join(", ")}]`);
       await this.pool.query("SELECT 1");
       this.logger.log("Connected to primary database (tenant registry)");
     } catch (error) {
@@ -1247,21 +1251,28 @@ var PrimaryBaseRepository = class {
     return this.database.drizzleClient;
   }
   /**
-  * Model query API for THIS repository's table (Prisma-like syntax)
+  * Model query API for THIS repository's table (Drizzle v2 relational queries)
   * Scoped to only the table this repository manages.
   * Returns a type-safe wrapper around Drizzle's RelationalQueryBuilder.
   *
   * @example
   * ```typescript
-  * // Use relational queries with type safety
+  * // Use relational queries with v2 object-based where syntax
   * const user = await this.model.findFirst({
-  *   where: eq(users.id, id),
+  *   where: { id },
   *   with: { posts: true, profile: true }
   * });
   * ```
   */
   get model() {
-    return this.database.drizzleClient.query[this.tableName];
+    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;
   }
   /**
   * Create a new repository instance
@@ -1284,6 +1295,7 @@ var PrimaryBaseRepository = class {
     this.tableName = getTableName(table);
     this.logger = new Logger6(this.constructor.name);
     this.logger.debug(`Initialized ${this.constructor.name}`);
+    this.logger.debug(`Table name from getTableName: '${this.tableName}'`);
   }
   /**
   * Create a new record
@@ -1317,21 +1329,31 @@ var PrimaryBaseRepository = class {
   */
   async findById(id) {
     this.logger.debug(`Finding record by ID: ${id}`);
-    const idColumn = this.table.id;
     return this.model.findFirst({
-      where: eq2(idColumn, id)
+      where: {
+        id
+      }
     });
   }
   /**
-  * Find a single record with custom where clause
+  * Find a single record with custom where clause (Drizzle v2 object-based syntax)
   *
-  * @param where - SQL condition
+  * @param where - Object-based filter condition
   * @returns Promise resolving to the record or undefined if not found
   *
   * @example
   * ```typescript
-  * import { eq } from 'drizzle-orm';
-  * const user = await userRepository.findOne(eq(users.email, 'user@example.com'));
+  * // Simple equality
+  * const user = await userRepository.findOne({ email: 'user@example.com' });
+  *
+  * // With operators
+  * const user = await userRepository.findOne({ age: { gte: 18 } });
+  *
+  * // Multiple conditions (AND)
+  * const user = await userRepository.findOne({
+  *   email: 'user@example.com',
+  *   status: 'ACTIVE'
+  * });
   * ```
   */
   async findOne(where) {
@@ -1341,25 +1363,33 @@ var PrimaryBaseRepository = class {
     });
   }
   /**
-  * Find multiple records
+  * Find multiple records (Drizzle v2 object-based syntax)
   *
   * @param options - Query options (where, orderBy, limit, offset)
   * @returns Promise resolving to an array of records
   *
   * @example
   * ```typescript
-  * import { eq, desc } from 'drizzle-orm';
-  *
   * // Find all users
   * const users = await userRepository.findMany();
   *
-  * // Find with filtering and pagination
+  * // Find with filtering and pagination (v2 object syntax)
   * const users = await userRepository.findMany({
-  *   where: eq(users.accountStatus, 'ACTIVE'),
-  *   orderBy: desc(users.createdAt),
+  *   where: { accountStatus: 'ACTIVE' },
+  *   orderBy: { createdAt: 'desc' },
   *   limit: 10,
   *   offset: 0
   * });
+  *
+  * // Multiple conditions
+  * const users = await userRepository.findMany({
+  *   where: {
+  *     AND: [
+  *       { status: 'ACTIVE' },
+  *       { age: { gte: 18 } }
+  *     ]
+  *   }
+  * });
   * ```
   */
   async findMany(options) {