@petradb/drizzle 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-import type { PgRemoteDatabase } from "drizzle-orm/pg-proxy";
-interface PetraDBSession {
+import { entityKind } from "drizzle-orm/entity";
+import { PgDatabase } from "drizzle-orm/pg-core/db";
+import { type PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import type { DrizzleConfig } from "drizzle-orm/utils";
+export interface PetraDBSession {
     execute(sql: string, options?: {
         rowMode?: "object" | "array";
     }): Promise<any[]>;
@@ -10,10 +13,16 @@ interface PetraDBSession {
     };
     close(): Promise<void>;
 }
-export interface PetraDBDrizzleDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends PgRemoteDatabase<TSchema> {
-    $session: PetraDBSession;
+export interface PetraDbQueryResult {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+}
+export declare class PetraDbDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends PgDatabase<PetraDbQueryResultHKT, TSchema> {
+    static readonly [entityKind] = "PetraDbDatabase";
 }
-export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(session: PetraDBSession, config?: {
-    schema?: TSchema;
-}): PetraDBDrizzleDatabase<TSchema>;
-export {};
+export interface PetraDbQueryResultHKT extends PgQueryResultHKT {
+    type: PetraDbQueryResult;
+}
+export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(session: PetraDBSession, config?: DrizzleConfig<TSchema>): PetraDbDatabase<TSchema> & {
+    $session: PetraDBSession;
+};

package/dist/index.js

@@ -1,21 +1,136 @@
-import { drizzle as pgProxyDrizzle } from "drizzle-orm/pg-proxy";
-export function drizzle(session, config) {
-    const db = pgProxyDrizzle(async (sql, params, method) => {
-        let results;
+import { entityKind } from "drizzle-orm/entity";
+import { DefaultLogger, NoopLogger } from "drizzle-orm/logger";
+import { PgDatabase } from "drizzle-orm/pg-core/db";
+import { PgDialect } from "drizzle-orm/pg-core/dialect";
+import { PgPreparedQuery, PgSession, PgTransaction, } from "drizzle-orm/pg-core/session";
+import { extractTablesRelationalConfig, createTableRelationsHelpers, } from "drizzle-orm/relations";
+import { fillPlaceholders, sql } from "drizzle-orm/sql";
+// drizzle-orm exports mapResultRow at runtime but not in its type declarations
+// @ts-ignore
+import { mapResultRow } from "drizzle-orm/utils";
+class PetraDbPreparedQuery extends PgPreparedQuery {
+    petraSession;
+    queryString;
+    params;
+    logger;
+    fields;
+    _isResponseInArrayMode;
+    customResultMapper;
+    static [entityKind] = "PetraDbPreparedQuery";
+    constructor(petraSession, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, query, queryMetadata, cacheConfig) {
+        super(query ?? { sql: queryString, params }, undefined, queryMetadata, cacheConfig);
+        this.petraSession = petraSession;
+        this.queryString = queryString;
+        this.params = params;
+        this.logger = logger;
+        this.fields = fields;
+        this._isResponseInArrayMode = _isResponseInArrayMode;
+        this.customResultMapper = customResultMapper;
+    }
+    async execute(placeholderValues = {}) {
+        const params = fillPlaceholders(this.params, placeholderValues);
+        this.logger.logQuery(this.queryString, params);
+        const { fields, queryString, petraSession, customResultMapper, } = this;
+        // joinsNotNullableMap is set internally by drizzle query builders
+        const joinsNotNullableMap = this.joinsNotNullableMap;
+        if (!fields && !customResultMapper) {
+            // Raw execute path (INSERT/UPDATE/DELETE without RETURNING, or raw SQL)
+            const results = await this._exec(queryString, params, "object");
+            const resultSet = results[0];
+            return {
+                rows: resultSet?.rows ?? [],
+                rowCount: resultSet?.rows?.length ?? 0,
+            };
+        }
+        // Query with field mapping (SELECT, or mutations with RETURNING)
+        const results = await this._exec(queryString, params, "array");
+        const resultSet = results[0];
+        const rows = resultSet?.rows ?? [];
+        if (customResultMapper) {
+            return customResultMapper(rows);
+        }
+        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+    }
+    async _exec(queryString, params, rowMode) {
         if (params.length > 0) {
-            const stmt = session.prepare(sql);
-            results = await stmt.execute(params, { rowMode: "array" });
+            const stmt = this.petraSession.prepare(queryString);
+            return stmt.execute(params, { rowMode });
+        }
+        return this.petraSession.execute(queryString, { rowMode });
+    }
+}
+class PetraDbSession extends PgSession {
+    petraSession;
+    schema;
+    static [entityKind] = "PetraDbSession";
+    logger;
+    constructor(petraSession, dialect, schema, options = {}) {
+        super(dialect);
+        this.petraSession = petraSession;
+        this.schema = schema;
+        this.logger = options.logger ?? new NoopLogger();
+    }
+    prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
+        return new PetraDbPreparedQuery(this.petraSession, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, query, queryMetadata, cacheConfig);
+    }
+    async transaction(transaction, config) {
+        const tx = new PetraDbTransaction(this.dialect, this, this.schema);
+        await tx.execute(sql `begin${config ? sql ` ${tx.getTransactionConfigSQL(config)}` : undefined}`);
+        try {
+            const result = await transaction(tx);
+            await tx.execute(sql `commit`);
+            return result;
         }
-        else {
-            results = await session.execute(sql, { rowMode: "array" });
+        catch (error) {
+            await tx.execute(sql `rollback`);
+            throw error;
         }
-        if (method === "execute") {
-            return { rows: [] };
+    }
+    async count(query) {
+        const res = await this.execute(query);
+        return Number(res.rows[0]["count"]);
+    }
+}
+class PetraDbTransaction extends PgTransaction {
+    static [entityKind] = "PetraDbTransaction";
+    async transaction(transaction) {
+        const savepointName = `sp${this.nestedIndex + 1}`;
+        const tx = new PetraDbTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+        await tx.execute(sql.raw(`savepoint ${savepointName}`));
+        try {
+            const result = await transaction(tx);
+            await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+            return result;
+        }
+        catch (err) {
+            await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+            throw err;
         }
-        // method === 'all'
-        const result = results[0];
-        return { rows: result?.rows ?? [] };
-    }, config);
+    }
+}
+export class PetraDbDatabase extends PgDatabase {
+    static [entityKind] = "PetraDbDatabase";
+}
+export function drizzle(session, config) {
+    const dialect = new PgDialect({ casing: config?.casing });
+    let logger;
+    if (config?.logger === true) {
+        logger = new DefaultLogger();
+    }
+    else if (config?.logger !== false && config?.logger !== undefined) {
+        logger = config.logger;
+    }
+    let schema;
+    if (config?.schema) {
+        const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+        schema = {
+            fullSchema: config.schema,
+            schema: tablesConfig.tables,
+            tableNamesMap: tablesConfig.tableNamesMap,
+        };
+    }
+    const petraDbSession = new PetraDbSession(session, dialect, schema, { logger });
+    const db = new PetraDbDatabase(dialect, petraDbSession, schema);
     db.$session = session;
     return db;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@petradb/drizzle",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Drizzle ORM driver for PetraDB",
   "type": "module",
   "exports": {
@@ -18,7 +18,7 @@
     "test": "node --test test/integration.mjs"
   },
   "peerDependencies": {
-    "@petradb/engine": ">=1.2.0",
+    "@petradb/engine": ">=1.2.15",
     "drizzle-orm": ">=0.38.0"
   },
   "devDependencies": {