duron 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/adapters/postgres/base.js

@@ -8,6 +8,14 @@ export class PostgresBaseAdapter extends Adapter {
     tables;
     schema = 'duron';
     migrateOnStart = true;
+    // ============================================================================
+    // Constructor
+    // ============================================================================
+    /**
+     * Create a new PostgresAdapter instance.
+     *
+     * @param options - Configuration options for the PostgreSQL adapter
+     */
     constructor(options) {
         super();
         this.connection = options.connection;
@@ -16,9 +24,21 @@ export class PostgresBaseAdapter extends Adapter {
         this.tables = createSchema(this.schema);
         this._initDb();
     }
+    /**
+     * Initialize the database connection and Drizzle instance.
+     */
     _initDb() {
         throw new Error('Not implemented');
     }
+    // ============================================================================
+    // Lifecycle Methods
+    // ============================================================================
+    /**
+     * Start the adapter.
+     * Runs migrations if enabled and sets up database listeners.
+     *
+     * @returns Promise resolving to `true` if started successfully, `false` otherwise
+     */
     async _start() {
         await this._listen(`ping-${this.id}`, async (payload) => {
             const fromClientId = JSON.parse(payload).fromClientId;
@@ -38,7 +58,16 @@ export class PostgresBaseAdapter extends Adapter {
         });
     }
     async _stop() {
+        // do nothing
     }
+    // ============================================================================
+    // Job Methods
+    // ============================================================================
+    /**
+     * Internal method to create a new job in the database.
+     *
+     * @returns Promise resolving to the job ID, or `null` if creation failed
+     */
     async _createJob({ queue, groupKey, input, timeoutMs, checksum, concurrencyLimit }) {
         const [result] = await this.db
             .insert(this.tables.jobsTable)
@@ -57,6 +86,11 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return result.id;
     }
+    /**
+     * Internal method to mark a job as completed.
+     *
+     * @returns Promise resolving to `true` if completed, `false` otherwise
+     */
     async _completeJob({ jobId, output }) {
         const result = await this.db
             .update(this.tables.jobsTable)
@@ -70,6 +104,11 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to mark a job as failed.
+     *
+     * @returns Promise resolving to `true` if failed, `false` otherwise
+     */
     async _failJob({ jobId, error }) {
         const result = await this.db
             .update(this.tables.jobsTable)
@@ -83,6 +122,11 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to cancel a job.
+     *
+     * @returns Promise resolving to `true` if cancelled, `false` otherwise
+     */
     async _cancelJob({ jobId }) {
         const result = await this.db
             .update(this.tables.jobsTable)
@@ -95,7 +139,14 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to retry a completed, cancelled, or failed job by creating a copy of it with status 'created' and cleared output/error.
+     * Uses SELECT FOR UPDATE to prevent concurrent retries from creating duplicate jobs.
+     *
+     * @returns Promise resolving to the job ID, or `null` if creation failed
+     */
     async _retryJob({ jobId }) {
+        // Use a single atomic query with FOR UPDATE lock to prevent race conditions
         const result = this._map(await this.db.execute(sql `
       WITH locked_source AS (
         -- Lock the source job row to prevent concurrent retries
@@ -169,6 +220,25 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return result[0].id;
     }
+    /**
+     * Internal method to time travel a job to restart from a specific step.
+     * The job must be in completed, failed, or cancelled status.
+     * Resets the job and ancestor steps to active status, deletes subsequent steps,
+     * and preserves completed parallel siblings.
+     *
+     * Algorithm:
+     * 1. Validate job is in terminal state (completed/failed/cancelled)
+     * 2. Find the target step and all its ancestors (using parent_step_id)
+     * 3. Determine which steps to keep:
+     *    - Steps completed BEFORE the target step (by created_at)
+     *    - Branch siblings that are completed (independent)
+     * 4. Delete steps that should not be kept
+     * 5. Reset ancestor steps to active status (they need to re-run)
+     * 6. Reset the target step to active status
+     * 7. Reset job to created status
+     *
+     * @returns Promise resolving to `true` if time travel succeeded, `false` otherwise
+     */
     async _timeTravelJob({ jobId, stepId }) {
         const result = this._map(await this.db.execute(sql `
       WITH RECURSIVE
@@ -336,16 +406,29 @@ export class PostgresBaseAdapter extends Adapter {
     `));
         return result.length > 0 && result[0].success === true;
     }
+    /**
+     * Internal method to delete a job by its ID.
+     * Active jobs cannot be deleted.
+     *
+     * @returns Promise resolving to `true` if deleted, `false` otherwise
+     */
     async _deleteJob({ jobId }) {
         const result = await this.db
             .delete(this.tables.jobsTable)
             .where(and(eq(this.tables.jobsTable.id, jobId), ne(this.tables.jobsTable.status, JOB_STATUS_ACTIVE)))
             .returning({ id: this.tables.jobsTable.id });
+        // Also delete associated steps
         if (result.length > 0) {
             await this.db.delete(this.tables.jobStepsTable).where(eq(this.tables.jobStepsTable.job_id, jobId));
         }
         return result.length > 0;
     }
+    /**
+     * Internal method to delete multiple jobs using the same filters as getJobs.
+     * Active jobs cannot be deleted and will be excluded from deletion.
+     *
+     * @returns Promise resolving to the number of jobs deleted
+     */
     async _deleteJobs(options) {
         const jobsTable = this.tables.jobsTable;
         const filters = options?.filters ?? {};
@@ -353,6 +436,13 @@ export class PostgresBaseAdapter extends Adapter {
         const result = await this.db.delete(jobsTable).where(where).returning({ id: jobsTable.id });
         return result.length;
     }
+    /**
+     * Internal method to fetch jobs from the database respecting concurrency limits per group.
+     * Uses the concurrency limit from the latest job created for each groupKey.
+     * Uses advisory locks to ensure thread-safe job fetching.
+     *
+     * @returns Promise resolving to an array of fetched jobs
+     */
     async _fetch({ batch }) {
         const result = this._map(await this.db.execute(sql `
       WITH group_concurrency AS (
@@ -464,6 +554,12 @@ export class PostgresBaseAdapter extends Adapter {
     `));
         return result;
     }
+    /**
+     * Internal method to recover stuck jobs (jobs that were active but the process that owned them is no longer running).
+     * In multi-process mode, pings other processes to check if they're alive before recovering their jobs.
+     *
+     * @returns Promise resolving to the number of jobs recovered
+     */
     async _recoverJobs(options) {
         const { checksums, multiProcessMode = false, processTimeout = 5_000 } = options;
         const unresponsiveClientIds = [this.id];
@@ -527,6 +623,14 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return 0;
     }
+    // ============================================================================
+    // Step Methods
+    // ============================================================================
+    /**
+     * Internal method to create or recover a job step by creating or resetting a step record in the database.
+     *
+     * @returns Promise resolving to the step, or `null` if creation failed
+     */
     async _createOrRecoverJobStep({ jobId, name, timeoutMs, retriesLimit, parentStepId, parallel = false, }) {
         const [result] = this._map(await this.db.execute(sql `
       WITH job_check AS (
@@ -539,7 +643,9 @@ export class PostgresBaseAdapter extends Adapter {
       step_existed AS (
         SELECT EXISTS(
           SELECT 1 FROM ${this.tables.jobStepsTable} s
-          WHERE s.job_id = ${jobId} AND s.name = ${name}
+          WHERE s.job_id = ${jobId} 
+            AND s.name = ${name}
+            AND s.parent_step_id IS NOT DISTINCT FROM ${parentStepId}
         ) AS existed
       ),
       upserted_step AS (
@@ -569,7 +675,7 @@ export class PostgresBaseAdapter extends Adapter {
           0,
           NULL
         WHERE EXISTS (SELECT 1 FROM job_check)
-        ON CONFLICT (job_id, name) DO UPDATE
+        ON CONFLICT (job_id, name, parent_step_id) DO UPDATE
         SET
           timeout_ms = ${timeoutMs},
           expires_at = now() + interval '${sql.raw(timeoutMs.toString())} milliseconds',
@@ -609,6 +715,7 @@ export class PostgresBaseAdapter extends Adapter {
         INNER JOIN job_check jc ON s.job_id = jc.id
         WHERE s.job_id = ${jobId}
           AND s.name = ${name}
+          AND s.parent_step_id IS NOT DISTINCT FROM ${parentStepId}
           AND NOT EXISTS (SELECT 1 FROM final_upserted)
       )
       SELECT * FROM final_upserted
@@ -621,6 +728,11 @@ export class PostgresBaseAdapter extends Adapter {
         }
         return result;
     }
+    /**
+     * Internal method to mark a job step as completed.
+     *
+     * @returns Promise resolving to `true` if completed, `false` otherwise
+     */
     async _completeJobStep({ stepId, output }) {
         const result = await this.db
             .update(this.tables.jobStepsTable)
@@ -635,6 +747,11 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobStepsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to mark a job step as failed.
+     *
+     * @returns Promise resolving to `true` if failed, `false` otherwise
+     */
     async _failJobStep({ stepId, error }) {
         const result = await this.db
             .update(this.tables.jobStepsTable)
@@ -649,6 +766,11 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobStepsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to delay a job step.
+     *
+     * @returns Promise resolving to `true` if delayed, `false` otherwise
+     */
     async _delayJobStep({ stepId, delayMs, error }) {
         const jobStepsTable = this.tables.jobStepsTable;
         const jobsTable = this.tables.jobsTable;
@@ -673,6 +795,11 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: jobStepsTable.id });
         return result.length > 0;
     }
+    /**
+     * Internal method to cancel a job step.
+     *
+     * @returns Promise resolving to `true` if cancelled, `false` otherwise
+     */
     async _cancelJobStep({ stepId }) {
         const result = await this.db
             .update(this.tables.jobStepsTable)
@@ -686,30 +813,51 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.jobStepsTable.id });
         return result.length > 0;
     }
+    // ============================================================================
+    // Query Methods
+    // ============================================================================
+    /**
+     * Internal method to get a job by its ID. Does not include step information.
+     */
     async _getJobById(jobId) {
+        const jobsTable = this.tables.jobsTable;
+        // Calculate duration as a SQL expression (finishedAt - startedAt in milliseconds)
+        const durationMs = sql `
+      CASE 
+        WHEN ${jobsTable.started_at} IS NOT NULL AND ${jobsTable.finished_at} IS NOT NULL 
+        THEN EXTRACT(EPOCH FROM (${jobsTable.finished_at} - ${jobsTable.started_at})) * 1000
+        ELSE NULL 
+      END
+    `.as('duration_ms');
         const [job] = await this.db
             .select({
-            id: this.tables.jobsTable.id,
-            actionName: this.tables.jobsTable.action_name,
-            groupKey: this.tables.jobsTable.group_key,
-            input: this.tables.jobsTable.input,
-            output: this.tables.jobsTable.output,
-            error: this.tables.jobsTable.error,
-            status: this.tables.jobsTable.status,
-            timeoutMs: this.tables.jobsTable.timeout_ms,
-            expiresAt: this.tables.jobsTable.expires_at,
-            startedAt: this.tables.jobsTable.started_at,
-            finishedAt: this.tables.jobsTable.finished_at,
-            createdAt: this.tables.jobsTable.created_at,
-            updatedAt: this.tables.jobsTable.updated_at,
-            concurrencyLimit: this.tables.jobsTable.concurrency_limit,
-            clientId: this.tables.jobsTable.client_id,
+            id: jobsTable.id,
+            actionName: jobsTable.action_name,
+            groupKey: jobsTable.group_key,
+            input: jobsTable.input,
+            output: jobsTable.output,
+            error: jobsTable.error,
+            status: jobsTable.status,
+            timeoutMs: jobsTable.timeout_ms,
+            expiresAt: jobsTable.expires_at,
+            startedAt: jobsTable.started_at,
+            finishedAt: jobsTable.finished_at,
+            createdAt: jobsTable.created_at,
+            updatedAt: jobsTable.updated_at,
+            concurrencyLimit: jobsTable.concurrency_limit,
+            clientId: jobsTable.client_id,
+            durationMs,
         })
-            .from(this.tables.jobsTable)
-            .where(eq(this.tables.jobsTable.id, jobId))
+            .from(jobsTable)
+            .where(eq(jobsTable.id, jobId))
             .limit(1);
         return job ?? null;
     }
+    /**
+     * Internal method to get all steps for a job with optional fuzzy search.
+     * Steps are always ordered by created_at ASC.
+     * Steps do not include output data.
+     */
     async _getJobSteps(options) {
         const { jobId, search } = options;
         const jobStepsTable = this.tables.jobStepsTable;
@@ -753,6 +901,7 @@ export class PostgresBaseAdapter extends Adapter {
         }
         const jobsTable = this.tables.jobsTable;
         const fuzzySearch = filters.search?.trim();
+        // Build WHERE clause parts using postgres template literals
         return and(filters.status
             ? inArray(jobsTable.status, Array.isArray(filters.status) ? filters.status : [filters.status])
             : undefined, filters.actionName
@@ -785,6 +934,10 @@ export class PostgresBaseAdapter extends Adapter {
             ? this.#buildJsonbWhereConditions(filters.outputFilter, jobsTable.output)
             : []));
     }
+    /**
+     * Internal method to get jobs with pagination, filtering, and sorting.
+     * Does not include step information or job output.
+     */
     async _getJobs(options) {
         const jobsTable = this.tables.jobsTable;
         const page = options?.page ?? 1;
@@ -793,6 +946,7 @@ export class PostgresBaseAdapter extends Adapter {
         const sortInput = options?.sort ?? { field: 'startedAt', order: 'desc' };
         const sorts = Array.isArray(sortInput) ? sortInput : [sortInput];
         const where = this._buildJobsWhereClause(filters);
+        // Get total count
         const total = await this.db.$count(jobsTable, where);
         if (!total) {
             return {
@@ -802,6 +956,14 @@ export class PostgresBaseAdapter extends Adapter {
                 pageSize,
             };
         }
+        // Calculate duration as a SQL expression (finishedAt - startedAt in milliseconds)
+        const durationMs = sql `
+      CASE 
+        WHEN ${jobsTable.started_at} IS NOT NULL AND ${jobsTable.finished_at} IS NOT NULL 
+        THEN EXTRACT(EPOCH FROM (${jobsTable.finished_at} - ${jobsTable.started_at})) * 1000
+        ELSE NULL 
+      END
+    `.as('duration_ms');
         const sortFieldMap = {
             createdAt: jobsTable.created_at,
             startedAt: jobsTable.started_at,
@@ -809,6 +971,7 @@ export class PostgresBaseAdapter extends Adapter {
             status: jobsTable.status,
             actionName: jobsTable.action_name,
             expiresAt: jobsTable.expires_at,
+            duration: durationMs,
         };
         const jobs = await this.db
             .select({
@@ -827,6 +990,7 @@ export class PostgresBaseAdapter extends Adapter {
             updatedAt: jobsTable.updated_at,
             concurrencyLimit: jobsTable.concurrency_limit,
             clientId: jobsTable.client_id,
+            durationMs,
         })
             .from(jobsTable)
             .where(where)
@@ -850,6 +1014,9 @@ export class PostgresBaseAdapter extends Adapter {
             pageSize,
         };
     }
+    /**
+     * Internal method to get a step by its ID with all information.
+     */
     async _getJobStepById(stepId) {
         const [step] = await this.db
             .select({
@@ -877,6 +1044,9 @@ export class PostgresBaseAdapter extends Adapter {
             .limit(1);
         return step ?? null;
     }
+    /**
+     * Internal method to get job status and updatedAt timestamp.
+     */
     async _getJobStatus(jobId) {
         const [job] = await this.db
             .select({
@@ -888,6 +1058,9 @@ export class PostgresBaseAdapter extends Adapter {
             .limit(1);
         return job ?? null;
     }
+    /**
+     * Internal method to get job step status and updatedAt timestamp.
+     */
     async _getJobStepStatus(stepId) {
         const [step] = await this.db
             .select({
@@ -899,6 +1072,9 @@ export class PostgresBaseAdapter extends Adapter {
             .limit(1);
         return step ?? null;
     }
+    /**
+     * Internal method to get action statistics including counts and last job created date.
+     */
     async _getActions() {
         const actionStats = this.db.$with('action_stats').as(this.db
             .select({
@@ -930,6 +1106,12 @@ export class PostgresBaseAdapter extends Adapter {
             })),
         };
     }
+    // ============================================================================
+    // Metrics Methods
+    // ============================================================================
+    /**
+     * Internal method to insert multiple metric records in a single batch.
+     */
     async _insertMetrics(metrics) {
         if (metrics.length === 0) {
             return 0;
@@ -948,10 +1130,15 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.metricsTable.id });
         return result.length;
     }
+    /**
+     * Internal method to get metrics for a job or step.
+     */
     async _getMetrics(options) {
         const metricsTable = this.tables.metricsTable;
         const filters = options.filters ?? {};
+        // Build WHERE clause
         const where = this._buildMetricsWhereClause(options.jobId, options.stepId, filters);
+        // Build sort
         const sortInput = options.sort ?? { field: 'timestamp', order: 'desc' };
         const sortFieldMap = {
             name: metricsTable.name,
@@ -959,6 +1146,7 @@ export class PostgresBaseAdapter extends Adapter {
             timestamp: metricsTable.timestamp,
             createdAt: metricsTable.created_at,
         };
+        // Get total count
         const total = await this.db.$count(metricsTable, where);
         if (!total) {
             return {
@@ -988,6 +1176,9 @@ export class PostgresBaseAdapter extends Adapter {
             total,
         };
     }
+    /**
+     * Internal method to delete all metrics for a job.
+     */
     async _deleteMetrics(options) {
         const result = await this.db
             .delete(this.tables.metricsTable)
@@ -995,6 +1186,9 @@ export class PostgresBaseAdapter extends Adapter {
             .returning({ id: this.tables.metricsTable.id });
         return result.length;
     }
+    /**
+     * Build WHERE clause for metrics queries.
+     */
     _buildMetricsWhereClause(jobId, stepId, filters) {
         const metricsTable = this.tables.metricsTable;
         return and(jobId ? eq(metricsTable.job_id, jobId) : undefined, stepId ? eq(metricsTable.step_id, stepId) : undefined, filters?.name
@@ -1009,6 +1203,25 @@ export class PostgresBaseAdapter extends Adapter {
             ? this.#buildJsonbWhereConditions(filters.attributesFilter, metricsTable.attributes)
             : []));
     }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Build WHERE conditions for JSONB filter using individual property checks.
+     * Each property becomes a separate condition using ->> operator and ILIKE for case-insensitive matching.
+     * Supports nested properties via dot notation and arrays.
+     *
+     * Example:
+     *   { "email": "tincho@gmail", "address.name": "nicolas", "products": ["chicle"] }
+     *   Generates:
+     *     input ->> 'email' ILIKE '%tincho@gmail%'
+     *     AND input ->> 'address' ->> 'name' ILIKE '%nicolas%'
+     *     AND EXISTS (SELECT 1 FROM jsonb_array_elements_text(input -> 'products') AS elem WHERE LOWER(elem) ILIKE LOWER('%chicle%'))
+     *
+     * @param filter - Flat record with dot-notation keys (e.g., { "email": "test", "address.name": "value", "products": ["chicle"] })
+     * @param jsonbColumn - The JSONB column name
+     * @returns Array of SQL conditions
+     */
     #buildJsonbWhereConditions(filter, jsonbColumn) {
         const conditions = [];
         for (const [key, value] of Object.entries(filter)) {
@@ -1016,11 +1229,16 @@ export class PostgresBaseAdapter extends Adapter {
             if (parts.length === 0) {
                 continue;
             }
+            // Build the JSONB path expression step by step
+            // For "address.name": input -> 'address' ->> 'name'  (-> for intermediate, ->> for final)
+            // For "email": input ->> 'email'  (->> for single level)
             let jsonbPath = sql `${jsonbColumn}`;
             if (parts.length === 1) {
+                // Single level: use ->> directly
                 jsonbPath = sql `${jsonbPath} ->> ${parts[0]}`;
             }
             else {
+                // Nested: use -> for intermediate steps, ->> for final step
                 for (let i = 0; i < parts.length - 1; i++) {
                     const part = parts[i];
                     if (part) {
@@ -1032,9 +1250,12 @@ export class PostgresBaseAdapter extends Adapter {
                     jsonbPath = sql `${jsonbPath} ->> ${lastPart}`;
                 }
             }
+            // Handle array values - check if JSONB array contains at least one of the values
             if (Array.isArray(value)) {
+                // Build condition: check if any element in the JSONB array matches any value in the filter array
                 const arrayValueConditions = value.map((arrayValue) => {
                     const arrayValueStr = String(arrayValue);
+                    // Get the array from JSONB: input -> 'products'
                     let arrayPath = sql `${jsonbColumn}`;
                     for (let i = 0; i < parts.length - 1; i++) {
                         const part = parts[i];
@@ -1046,6 +1267,7 @@ export class PostgresBaseAdapter extends Adapter {
                     if (lastPart) {
                         arrayPath = sql `${arrayPath} -> ${lastPart}`;
                     }
+                    // Check if the JSONB array contains the value (case-insensitive for strings)
                     if (typeof arrayValue === 'string') {
                         return sql `EXISTS (
               SELECT 1
@@ -1054,30 +1276,62 @@ export class PostgresBaseAdapter extends Adapter {
             )`;
                     }
                     else {
+                        // For non-string values, use exact containment
                         return sql `${arrayPath} @> ${sql.raw(JSON.stringify([arrayValue]))}::jsonb`;
                     }
                 });
+                // Combine array conditions with OR (at least one must match)
                 if (arrayValueConditions.length > 0) {
                     conditions.push(arrayValueConditions.reduce((acc, condition, idx) => (idx === 0 ? condition : sql `${acc} OR ${condition}`)));
                 }
             }
             else if (typeof value === 'string') {
+                // String values: use ILIKE for case-insensitive partial matching
                 conditions.push(sql `COALESCE(${jsonbPath}, '') ILIKE ${`%${value}%`}`);
             }
             else {
+                // Non-string, non-array values: use exact match
+                // Convert JSONB value to text for comparison
                 conditions.push(sql `${jsonbPath}::text = ${String(value)}`);
             }
         }
         return conditions;
     }
+    // ============================================================================
+    // Protected Methods
+    // ============================================================================
+    /**
+     * Send a PostgreSQL notification.
+     *
+     * @param event - The event name
+     * @param data - The data to send
+     * @returns Promise resolving to `void`
+     */
     async _notify(_event, _data) {
+        // do nothing
     }
+    /**
+     * Listen for PostgreSQL notifications.
+     *
+     * @param event - The event name to listen for
+     * @param callback - Callback function to handle notifications
+     * @returns Promise resolving to an object with an `unlisten` function
+     */
     async _listen(_event, _callback) {
+        // do nothing
         return {
             unlisten: () => {
+                // do nothing
             },
         };
     }
+    /**
+     * Map database query results to the expected format.
+     * Can be overridden by subclasses to handle different result formats.
+     *
+     * @param result - The raw database query result
+     * @returns The mapped result
+     */
     _map(result) {
         return result;
     }

package/dist/adapters/postgres/pglite.d.ts

@@ -3,12 +3,49 @@ import { type AdapterOptions, PostgresBaseAdapter } from './base.js';
 import type createSchema from './schema.js';
 type Schema = ReturnType<typeof createSchema>;
 export type DB = ReturnType<typeof drizzle<Schema>>;
+/**
+ * PGLite adapter implementation for Duron.
+ * Extends PostgresAdapter to work with PGLite (in-memory PostgreSQL).
+ *
+ * @template Options - The adapter options type
+ */
 export declare class PGLiteAdapter extends PostgresBaseAdapter<DB, string | undefined> {
+    /**
+     * Start the adapter.
+     * Runs migrations if enabled and sets up database listeners.
+     *
+     * @returns Promise resolving to `true` if started successfully, `false` otherwise
+     */
     protected _start(): Promise<void>;
     protected _stop(): Promise<void>;
+    /**
+     * Map database query results to the expected format.
+     * PGLite returns results in a `rows` property, so we extract that.
+     *
+     * @param result - The raw database query result
+     * @returns The mapped result (result.rows)
+     */
     protected _map(result: any): any;
+    /**
+     * Initialize the PGLite database connection.
+     * Creates a new Drizzle instance without connection options.
+     */
     protected _initDb(): void;
+    /**
+     * Send a PGLite notification.
+     *
+     * @param event - The event name
+     * @param data - The data to send
+     * @returns Promise resolving to `void`
+     */
     protected _notify(event: string, data: any): Promise<void>;
+    /**
+     * Listen for PGLite notifications.
+     *
+     * @param event - The event name to listen for
+     * @param callback - Callback function to handle notifications
+     * @returns Promise resolving to an object with an `unlisten` function
+     */
     protected _listen(event: string, callback: (payload: string) => void): Promise<{
         unlisten: () => void;
     }>;

package/dist/adapters/postgres/pglite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres/pglite.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAG5C,OAAO,EAAE,KAAK,cAAc,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,KAAK,YAAY,MAAM,aAAa,CAAA;AAE3C,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE7C,MAAM,MAAM,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;AAQnD,qBAAa,aAAc,SAAQ,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;cAOnD,MAAM;cAYN,KAAK;cAWX,IAAI,CAAC,MAAM,EAAE,GAAG;cAQhB,OAAO;cAoBD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;cAWhD,OAAO,CAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAClC,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CASrC;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,cAAc,CAAC,MAAM,GAAG,SAAS,CAAC,kBAExE,CAAA"}
+{"version":3,"file":"pglite.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres/pglite.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAG5C,OAAO,EAAE,KAAK,cAAc,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,KAAK,YAAY,MAAM,aAAa,CAAA;AAE3C,KAAK,MAAM,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE7C,MAAM,MAAM,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAA;AAEnD;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5E;;;;;OAKG;cACsB,MAAM;cAYN,KAAK;IAI9B;;;;;;OAMG;cACgB,IAAI,CAAC,MAAM,EAAE,GAAG;IAInC;;;OAGG;cACgB,OAAO;IAa1B;;;;;;OAMG;cACsB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzE;;;;;;OAMG;cACsB,OAAO,CAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAClC,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CASrC;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,cAAc,CAAC,MAAM,GAAG,SAAS,CAAC,kBAExE,CAAA"}