@vritti/api-sdk 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -280,10 +280,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 = (0, import_node_postgres.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) {
@@ -1326,21 +1330,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
@@ -1363,6 +1374,7 @@ var PrimaryBaseRepository = class {
     this.tableName = (0, import_drizzle_orm2.getTableName)(table);
     this.logger = new import_common11.Logger(this.constructor.name);
     this.logger.debug(`Initialized ${this.constructor.name}`);
+    this.logger.debug(`Table name from getTableName: '${this.tableName}'`);
   }
   /**
   * Create a new record
@@ -1396,21 +1408,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: (0, import_drizzle_orm2.eq)(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) {
@@ -1420,25 +1442,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) {