@primate/oracledb 0.1.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) Terrablue <terrablue@proton.me> and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/private/ColumnTypes.d.ts

@@ -0,0 +1,23 @@
+import type { JSONValue, TypedArray } from "@rcompat/type";
+type Param = Array<unknown> | bigint | boolean | Date | null | number | object | string | TypedArray;
+type Validate<T extends {
+    [K in keyof T]: Param;
+}> = T;
+type ColumnTypes = Validate<{
+    BOOLEAN: boolean;
+    BLOB: TypedArray;
+    BINARY_FLOAT: number;
+    BINARY_DOUBLE: number;
+    NUNBER: number;
+    "NUMBER(3)": number;
+    "NUMBER(5)": number;
+    "NUMBER(10)": number;
+    "NUMBER(20)": string;
+    "VARCHAR2(36)": string;
+    "VARCHAR2(40)": string;
+    "VARCHAR2(4000)": string;
+    TIMESTAMP: Date;
+    JSON: JSONValue;
+}>;
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/OracleDB.d.ts

@@ -0,0 +1,60 @@
+import type { As, CheckPlaceholders, DataDict, ExtractPlaceholders, Schema, Sort, SQLDB, With } from "@primate/core/db";
+import type { Dict } from "@rcompat/type";
+import oracledb from "oracledb";
+import type { ObjectType, Parsed } from "pema";
+declare const schema: ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly host: import("pema").DefaultType<import("pema").StringType, "localhost">;
+    readonly port: import("pema").DefaultType<import("pema").UintType<"u32">, 1521>;
+    readonly database: import("pema").StringType;
+    readonly username: import("pema").OptionalType<import("pema").StringType>;
+    readonly password: import("pema").OptionalType<import("pema").StringType>;
+}>, {
+    host: string;
+    port: number;
+    database: string;
+    username: string | undefined;
+    password: string | undefined;
+}>;
+export default class OracleDB implements SQLDB<oracledb.Connection> {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input, options?: {
+        debug?: boolean;
+    });
+    get client(): oracledb.Connection;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): Promise<number>;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        offset?: number;
+        sort?: Sort;
+        with?: With;
+    }): Promise<Dict[]>;
+    close(): Promise<void>;
+    get explain(): Dict<{
+        query: string;
+    }>;
+    get schema(): Schema;
+    create<O extends Dict>(as: As, record: Dict): Promise<O>;
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): Promise<number>;
+    sql<Q extends string, I extends ObjectType<{
+        [K in ExtractPlaceholders<Q>]: Parsed<unknown>;
+    }> | undefined, O extends Parsed<unknown> | undefined>(options: {
+        input?: I extends ObjectType<any> ? CheckPlaceholders<I, Q> : I;
+        query: Q;
+        output?: O;
+    }): (args: I extends ObjectType<any> ? I["infer"] : void) => Promise<O extends Parsed<unknown> ? O["infer"] : void>;
+}
+export {};
+//# sourceMappingURL=OracleDB.d.ts.map

package/lib/private/OracleDB.js

@@ -0,0 +1,571 @@
+import typemap from "#typemap";
+import base from "@primate/core/db";
+import E from "@primate/core/db/errors";
+import sql from "@primate/core/db/sql";
+import assert from "@rcompat/assert";
+import is from "@rcompat/is";
+import oracledb from "oracledb";
+import p from "pema";
+const VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function quote(name) {
+    if (!VALID_IDENTIFIER.test(name))
+        throw E.identifier_invalid(name);
+    return `"${name}"`;
+}
+function get_column(key) {
+    return typemap[key].column;
+}
+async function bind_value(key, value) {
+    if (is.null(value))
+        return null;
+    return typemap[key].bind(value);
+}
+function order_by(sort) {
+    if (is.undefined(sort))
+        return "";
+    const entries = Object.entries(sort);
+    if (entries.length === 0)
+        return "";
+    return ` ORDER BY ${entries.map(([k, dir]) => {
+        const direction = dir.toLowerCase() === "desc" ? "DESC" : "ASC";
+        return `${quote(k)} ${direction}`;
+    }).join(", ")}`;
+}
+function columns_to_types(row) {
+    const data_type = row.data_type.toUpperCase();
+    const char_length = Number(row.char_length ?? row.data_length ?? 0);
+    const precision = is.null(row.data_precision)
+        ? null
+        : Number(row.data_precision);
+    const scale = is.null(row.data_scale) ? 0 : Number(row.data_scale);
+    if (data_type === "BLOB")
+        return ["blob"];
+    if (data_type === "BOOLEAN")
+        return ["boolean"];
+    if (data_type === "BINARY_FLOAT")
+        return ["f32"];
+    if (data_type === "BINARY_DOUBLE")
+        return ["f64"];
+    if (data_type === "JSON")
+        return ["json"];
+    if (data_type.startsWith("TIMESTAMP"))
+        return ["datetime"];
+    if (data_type === "VARCHAR2") {
+        if (char_length === 36)
+            return base.UUID_TYPES;
+        if (char_length === 40)
+            return ["i128", "u128"];
+        if (char_length === 4000)
+            return ["string", "time", "url"];
+        return ["string"];
+    }
+    if (data_type === "NUMBER" && scale === 0) {
+        if (precision === 3)
+            return ["i8", "u8"];
+        if (precision === 5)
+            return ["i16", "u16"];
+        if (precision === 10)
+            return ["i32", "u32"];
+        if (precision === 20)
+            return ["i64", "u64"];
+    }
+    return [];
+}
+function limit(n) {
+    return is.defined(n) ? ` FETCH FIRST ${n} ROWS ONLY` : "";
+}
+function unbind_value(key, value) {
+    return typemap[key].unbind(value);
+}
+function unbind(types, row) {
+    return sql.unbind(types, row, unbind_value);
+}
+const schema = p({
+    host: p.string.default("localhost"),
+    port: p.uint.port().default(1521),
+    database: p.string,
+    username: p.string.optional(),
+    password: p.string.optional(),
+});
+export default class OracleDB {
+    static config;
+    #connection;
+    #config;
+    #debug = false;
+    #explain = {};
+    constructor(config, options) {
+        this.#config = schema.parse(config);
+        this.#debug = options?.debug ?? false;
+    }
+    get client() {
+        return this.#connection;
+    }
+    async #connect() {
+        if (is.undefined(this.#connection)) {
+            const { username, password, host, port, database } = this.#config;
+            this.#connection = await oracledb.getConnection({
+                user: username,
+                password,
+                connectString: `${host}:${port}/${database}`,
+            });
+            // return objects as plain dicts with lowercase keys
+            this.#connection.callTimeout = 0;
+        }
+        return this.#connection;
+    }
+    async #sql(q, params = []) {
+        const conn = await this.#connect();
+        const EXECUTE_OPTIONS = {
+            outFormat: oracledb.OUT_FORMAT_OBJECT,
+            // fetch NUMBER columns as strings to preserve bigint precision
+            fetchTypeHandler(metadata) {
+                if (metadata.dbType === oracledb.DB_TYPE_NUMBER) {
+                    return { type: oracledb.STRING };
+                }
+            },
+        };
+        const result = await conn.execute(q, params, {
+            ...EXECUTE_OPTIONS,
+            autoCommit: false,
+        });
+        // lowercase all keys
+        return (result.rows ?? []).map((row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k.toLowerCase(), v])));
+    }
+    async #where(as, where, index = 1) {
+        const keys = Object.keys(where);
+        if (keys.length === 0)
+            return { WHERE: "", params: [], next_index: index };
+        const parts = [];
+        const params = [];
+        let i = index;
+        for (const field of keys) {
+            const raw = where[field];
+            const datatype = as.types[field];
+            const column = quote(field);
+            if (is.null(raw)) {
+                parts.push(`${column} IS NULL`);
+                continue;
+            }
+            if (is.dict(raw)) {
+                const ops = Object.entries(raw);
+                if (ops.length === 0)
+                    throw E.operator_empty(field);
+                for (const [op, op_value] of ops) {
+                    const placeholder = op === "$in" ? "" : `:${i++}`;
+                    switch (op) {
+                        case "$like":
+                            parts.push(`${column} LIKE ${placeholder} ESCAPE '\\'`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$ilike":
+                            parts.push(`UPPER(${column}) LIKE UPPER(${placeholder}) ESCAPE '\\'`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$ne":
+                            parts.push(`${column} != ${placeholder}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        case "$gt":
+                        case "$gte":
+                        case "$lt":
+                        case "$lte":
+                        case "$after":
+                        case "$before": {
+                            const sql_op = sql.OPS[op];
+                            parts.push(`${column} ${sql_op} ${placeholder}`);
+                            params.push(await bind_value(datatype, op_value));
+                            break;
+                        }
+                        case "$in": {
+                            const array = op_value;
+                            const placeholders = [];
+                            for (const value of array) {
+                                placeholders.push(`:${i++}`);
+                                params.push(await bind_value(datatype, value));
+                            }
+                            parts.push(`${column} IN (${placeholders.join(", ")})`);
+                            break;
+                        }
+                        default:
+                            throw E.operator_unknown(field, op);
+                    }
+                }
+                continue;
+            }
+            parts.push(`${column} = :${i++}`);
+            params.push(await bind_value(datatype, raw));
+        }
+        return {
+            WHERE: `WHERE ${parts.join(" AND ")}`,
+            params,
+            next_index: i,
+        };
+    }
+    async #base_query(as, args) {
+        const { fields } = args;
+        const SELECT = is.defined(fields) ? fields.map(quote).join(", ") : "*";
+        const table = quote(as.table);
+        const { WHERE, params } = await this.#where(as, args.where);
+        const ORDER_BY = order_by(args.sort);
+        const OFFSET = is.defined(args.offset) ? ` OFFSET ${args.offset} ROWS` : "";
+        const LIMIT = is.defined(args.limit)
+            ? `${OFFSET} FETCH FIRST ${args.limit} ROWS ONLY`
+            : "";
+        return {
+            query: `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`,
+            params,
+        };
+    }
+    async #read(as, args) {
+        const { query, params } = await this.#base_query(as, args);
+        const rows = await this.#sql(query, params);
+        return rows.map(r => unbind(as.types, r));
+    }
+    async #count(as, where) {
+        const { WHERE, params } = await this.#where(as, where);
+        const q = `SELECT COUNT(*) AS n FROM ${quote(as.table)} ${WHERE}`;
+        const rows = await this.#sql(q, params);
+        return Number(rows[0]?.n ?? 0);
+    }
+    async #read_joined(as, args) {
+        if (is.null(as.pk))
+            throw E.relation_requires_pk("parent");
+        const [[, relation]] = Object.entries(args.with);
+        if (is.null(relation.as.pk))
+            throw E.relation_requires_pk("target");
+        const aliases = sql.aliases([as.table, relation.as.table]);
+        const alias = aliases[as.table];
+        const r_alias = aliases[relation.as.table];
+        const fields = base.fields(args.fields, as.pk) ?? Object.keys(as.types);
+        const r_fields = base.fields(relation.fields, relation.fk, relation.as.pk)
+            ?? Object.keys(relation.as.types);
+        const SELECT = [
+            ...fields.map(f => `${alias}.${quote(f)} AS ${alias}_${f}`),
+            ...r_fields.map(f => `${r_alias}.${quote(f)} AS ${r_alias}_${f}`),
+        ].join(", ");
+        const { query, params } = await this.#base_query(as, { ...args, fields });
+        const JOIN = `LEFT JOIN ${quote(relation.as.table)} ${r_alias}
+      ON ${r_alias}.${quote(relation.fk)} = ${alias}.${quote(as.pk)}`;
+        const q = `SELECT ${SELECT} FROM (${query}) ${alias} ${JOIN}`;
+        const rows = await this.#sql(q, params);
+        return sql.nest(as, { rows, aliases }, args, unbind_value);
+    }
+    async #read_phased(as, args) {
+        const fields = base.expand(as, args.fields, args.with);
+        const rows = await this.#read(as, { ...args, fields });
+        const out = rows.map(row => base.project(row, args.fields));
+        for (const [table, relation] of Object.entries(args.with)) {
+            await this.#attach_relation(as, { rows, out, table, relation });
+        }
+        return out;
+    }
+    async #attach_relation(as, args) {
+        const relation = args.relation;
+        const by = relation.reverse === true ? relation.as.pk : relation.fk;
+        if (is.null(by))
+            throw E.relation_requires_pk("target");
+        const parent_by = relation.reverse === true ? relation.fk : as.pk;
+        if (is.null(parent_by))
+            throw E.relation_requires_pk("parent");
+        const join_values = [...new Set(args.rows.map(r => r[parent_by]).filter(v => v != null))];
+        const is_many = relation.kind === "many";
+        const many = is_many ? [] : null;
+        if (join_values.length === 0) {
+            for (const row of args.out)
+                row[args.table] = many;
+            return;
+        }
+        const related = await this.#load_related({ by, join_values, ...relation });
+        const grouped = new Map();
+        for (const row of related) {
+            const key = row[by];
+            if (is.null(key))
+                continue;
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(row);
+        }
+        for (let i = 0; i < args.out.length; i++) {
+            const join_value = args.rows[i][parent_by];
+            if (is.null(join_value)) {
+                args.out[i][args.table] = is_many ? [] : null;
+                continue;
+            }
+            const rows = grouped.get(join_value) ?? [];
+            args.out[i][args.table] = is_many
+                ? rows.map(r => base.project(r, relation.fields))
+                : rows[0] ? base.project(rows[0], relation.fields) : null;
+        }
+    }
+    async #load_related(args) {
+        const per_parent = args.kind === "one" ? 1 : args.limit;
+        const { WHERE: _where, params: where_params, next_index } = await this.#where(args.as, args.where);
+        const where_part = _where.length > 0 ? _where.slice("WHERE ".length) : "";
+        const datatype = args.as.types[args.by];
+        let next_i = next_index;
+        const in_placeholders = [];
+        const in_params = [];
+        for (const v of args.join_values) {
+            in_placeholders.push(`:${next_i++}`);
+            in_params.push(await bind_value(datatype, v));
+        }
+        const in_part = `${quote(args.by)} IN (${in_placeholders.join(", ")})`;
+        const WHERE = is.text(where_part)
+            ? `WHERE (${where_part}) AND (${in_part})`
+            : `WHERE ${in_part}`;
+        const all_columns = Object.keys(args.as.types);
+        const fields = args.fields !== undefined && args.fields.length > 0
+            ? args.fields
+            : all_columns;
+        const select_fields = [...new Set([...fields, args.by])];
+        const SELECT = select_fields.map(quote).join(", ");
+        const ORDER_BY = ` ORDER BY ${quote(args.by)} ASC${is.defined(args.sort)
+            ? ", " + Object.entries(args.sort).map(([k, dir]) => `${quote(k)} ${dir.toLowerCase() === "desc" ? "DESC" : "ASC"}`).join(", ")
+            : ""}`;
+        const table = quote(args.as.table);
+        let q;
+        if (is.defined(per_parent)) {
+            const rn_order = is.defined(args.sort)
+                ? Object.entries(args.sort).map(([k, dir]) => `${quote(k)} ${dir.toLowerCase() === "desc" ? "DESC" : "ASC"}`).join(", ")
+                : "";
+            q = `SELECT ${SELECT} FROM (
+        SELECT ${SELECT},
+          ROW_NUMBER() OVER (
+            PARTITION BY ${quote(args.by)}
+            ORDER BY ${quote(args.by)}${is.text(rn_order) ? ", " + rn_order : ""}
+          ) AS "__rn"
+        FROM ${table}
+        ${WHERE}
+      )
+      WHERE "__rn" <= ${per_parent}
+      ${ORDER_BY}`;
+        }
+        else {
+            q = `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}`;
+        }
+        const params = [...where_params, ...in_params];
+        const rows = await this.#sql(q, params);
+        return rows.map(r => unbind(args.as.types, r));
+    }
+    async read(as, args) {
+        assert.dict(args.where);
+        this.#explain = {};
+        if (args.count === true)
+            return this.#count(as, args.where);
+        if (base.withed(args)) {
+            return sql.joinable(as, args.with)
+                ? this.#read_joined(as, args)
+                : this.#read_phased(as, args);
+        }
+        return this.#read(as, args);
+    }
+    async close() {
+        await this.#connection?.close();
+        this.#connection = undefined;
+    }
+    get explain() {
+        return this.#explain;
+    }
+    get schema() {
+        return {
+            create: async (table, pk, types) => {
+                const columns = [];
+                for (const [key, value] of Object.entries(types)) {
+                    const column_type = get_column(value);
+                    const column = quote(key);
+                    const c = `${column} ${column_type}`;
+                    if (key === pk.name) {
+                        const is_identity = pk.generate && column_type.startsWith("NUMBER");
+                        if (is_identity) {
+                            columns.push(`${c} GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY`);
+                        }
+                        else {
+                            columns.push(`${c} PRIMARY KEY`);
+                        }
+                    }
+                    else {
+                        columns.push(`${c}`);
+                    }
+                }
+                await this.#sql(`CREATE TABLE IF NOT EXISTS ${quote(table)} (${columns.join(", ")})`);
+            },
+            delete: async (table) => {
+                await this.#sql(`DROP TABLE IF EXISTS ${quote(table)} CASCADE CONSTRAINTS PURGE`);
+            },
+            introspect: async (table /*, pk? */) => {
+                const exists = await this.#sql(`
+        SELECT COUNT(*) AS n
+        FROM USER_TABLES
+        WHERE TABLE_NAME = :1
+        `, [table]);
+                if (Number(exists[0]?.n ?? 0) === 0)
+                    return null;
+                const rows = await this.#sql(`
+        SELECT
+          COLUMN_NAME,
+          DATA_TYPE,
+          DATA_LENGTH,
+          CHAR_LENGTH,
+          DATA_PRECISION,
+          DATA_SCALE
+        FROM USER_TAB_COLUMNS
+        WHERE TABLE_NAME = :1
+        ORDER BY COLUMN_ID
+        `, [table]);
+                const result = {};
+                for (const row of rows) {
+                    const candidates = columns_to_types(row);
+                    if (candidates.length > 0) {
+                        result[row.column_name] = candidates;
+                    }
+                }
+                return result;
+            },
+            alter: async (table, diff) => {
+                const existing = await this.schema.introspect(table);
+                if (is.null(existing))
+                    throw E.table_not_found(table);
+                // rename first
+                for (const [from, to] of diff.rename) {
+                    await this.#sql(`ALTER TABLE ${quote(table)} RENAME COLUMN ${quote(from)} TO ${quote(to)}`);
+                }
+                // drop next
+                for (const field of diff.drop) {
+                    await this.#sql(`ALTER TABLE ${quote(table)} DROP COLUMN ${quote(field)}`);
+                }
+                // add last
+                for (const [field, type] of Object.entries(diff.add)) {
+                    await this.#sql(`ALTER TABLE ${quote(table)} ADD (${quote(field)} ${get_column(type)})`);
+                }
+            },
+        };
+    }
+    async create(as, record) {
+        assert.dict(record);
+        const pk = as.pk;
+        const table = quote(as.table);
+        // PK provided or none defined
+        if (is.null(pk) || pk in record) {
+            const fields = Object.keys(record);
+            if (fields.length === 0) {
+                await this.#sql(`INSERT INTO ${table} VALUES (DEFAULT)`);
+                return record;
+            }
+            const keys = fields.map(quote).join(", ");
+            const values = fields.map((_, i) => `:${i + 1}`).join(", ");
+            const params = await this.#create_params(as, record);
+            await this.#sql(`INSERT INTO ${table} (${keys}) VALUES (${values})`, params);
+            return record;
+        }
+        // PK missing
+        if (as.generate_pk === false)
+            throw E.pk_required(pk);
+        const type = as.types[pk];
+        // UUID — generate client-side
+        if (base.is_uuid_type(type)) {
+            const pk_value = base.generate_uuid(type);
+            const to_insert = { ...record, [pk]: pk_value };
+            const fields = Object.keys(to_insert);
+            const keys = fields.map(quote).join(", ");
+            const values = fields.map((_, i) => `:${i + 1}`).join(", ");
+            const params = await this.#create_params(as, to_insert);
+            await this.#sql(`INSERT INTO ${table} (${keys}) VALUES (${values})`, params);
+            return to_insert;
+        }
+        // bigint — generate client-side via MAX
+        if (base.BIGINT_STRING_TYPES.includes(type)) {
+            const q = `SELECT MAX(${quote(pk)}) AS v FROM ${table}`;
+            const rows = await this.#sql(q);
+            const pk_value = rows[0]?.v !== null && rows[0]?.v !== undefined
+                ? BigInt(rows[0].v) + 1n
+                : 1n;
+            const to_insert = { ...record, [pk]: pk_value };
+            const fields = Object.keys(to_insert);
+            const keys = fields.map(quote).join(", ");
+            const values = fields.map((_, i) => `:${i + 1}`).join(", ");
+            const params = await this.#create_params(as, to_insert);
+            await this.#sql(`INSERT INTO ${table} (${keys}) VALUES (${values})`, params);
+            return to_insert;
+        }
+        // integer — use GENERATED ALWAYS AS IDENTITY, get PK back via RETURNING INTO
+        const fields = Object.keys(record);
+        const keys = fields.length > 0 ? fields.map(quote).join(", ") : undefined;
+        const values = fields.map((_, i) => `:${i + 1}`).join(", ");
+        const params = await this.#create_params(as, record);
+        const out_bind = { dir: oracledb.BIND_OUT, type: oracledb.NUMBER };
+        const q = fields.length > 0
+            ? `INSERT INTO ${table} (${keys}) VALUES (${values}) RETURNING ${quote(pk)} INTO :out`
+            : `INSERT INTO ${table} VALUES (DEFAULT) RETURNING ${quote(pk)} INTO :out`;
+        const conn = await this.#connect();
+        const result = await conn.execute(q, [...params, out_bind], { autoCommit: true });
+        const out = result.outBinds[0];
+        const pk_raw = Array.isArray(out) ? out[0] : out;
+        return { ...record, [pk]: unbind_value(type, pk_raw) };
+    }
+    #create_params(as, record) {
+        return Promise.all(Object.keys(record).map(field => bind_value(as.types[field], record[field])));
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const set_keys = Object.keys(args.set);
+        const set_parts = [];
+        const set_params = [];
+        let i = 1;
+        for (const k of set_keys) {
+            set_parts.push(`${quote(k)} = :${i++}`);
+            set_params.push(await bind_value(as.types[k], args.set[k]));
+        }
+        const SET = `SET ${set_parts.join(", ")}`;
+        const { WHERE, params } = await this.#where(as, args.where, i);
+        const q = `UPDATE ${quote(as.table)} ${SET} ${WHERE}`;
+        const conn = await this.#connect();
+        const result = await conn.execute(q, [...set_params, ...params], {
+            autoCommit: true,
+        });
+        return result.rowsAffected ?? 0;
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        const { WHERE, params } = await this.#where(as, args.where);
+        const q = `DELETE FROM ${quote(as.table)} ${WHERE}`;
+        const conn = await this.#connect();
+        const result = await conn.execute(q, params, { autoCommit: true });
+        return result.rowsAffected ?? 0;
+    }
+    sql(options) {
+        if (is.defined(options.input)) {
+            const placeholders = new Set([...options.query.matchAll(/:(\w+)/g)].map(m => m[1]));
+            const input_keys = new Set(Object.keys(options.input.properties));
+            for (const key of input_keys) {
+                if (!placeholders.has(key))
+                    throw E.sql_placeholder_missing(key);
+            }
+            for (const key of placeholders) {
+                if (!input_keys.has(key))
+                    throw E.sql_input_missing(key);
+            }
+        }
+        return async (args) => {
+            const input = is.defined(options.input)
+                ? options.input.parse(args)
+                : undefined;
+            const params = [];
+            const name_to_index = new Map();
+            const query = options.query.replace(/:(\w+)/g, (_, name) => {
+                if (!name_to_index.has(name)) {
+                    name_to_index.set(name, params.length + 1);
+                    const types = Object.fromEntries(Object.entries(options.input.properties)
+                        .map(([k, v]) => [k, v.datatype]));
+                    params.push(bind_value(types[name], input[name]));
+                }
+                return `:${name_to_index.get(name)}`;
+            });
+            const rows = await this.#sql(query, params);
+            return (is.defined(options.output)
+                ? options.output.parse(rows)
+                : undefined);
+        };
+    }
+}
+//# sourceMappingURL=OracleDB.js.map

package/lib/private/typemap.d.ts

@@ -0,0 +1,5 @@
+import type ColumnTypes from "#ColumnTypes";
+import type { TypeMap } from "@primate/core/db";
+declare const typemap: TypeMap<ColumnTypes>;
+export default typemap;
+//# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -0,0 +1,76 @@
+import oracledb from "oracledb";
+function identity(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => value,
+    };
+}
+function number(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => Number(value),
+    };
+}
+const typemap = {
+    blob: {
+        async bind(value) {
+            const arrayBuffer = await value.arrayBuffer();
+            return new Uint8Array(arrayBuffer);
+        },
+        column: "BLOB",
+        unbind(value) {
+            return new Blob([value], { type: "application/octet-stream" });
+        },
+    },
+    boolean: identity("BOOLEAN"),
+    datetime: identity("TIMESTAMP"),
+    f32: identity("BINARY_FLOAT"),
+    f64: identity("BINARY_DOUBLE"),
+    i8: number("NUMBER(3)"),
+    i16: number("NUMBER(5)"),
+    i32: number("NUMBER(10)"),
+    i64: {
+        bind(value) { return String(value); },
+        column: "NUMBER(20)",
+        unbind(value) { return BigInt(value); },
+    },
+    i128: {
+        bind(value) { return String(value); },
+        column: "VARCHAR2(40)",
+        unbind(value) { return BigInt(value); },
+    },
+    u8: number("NUMBER(3)"),
+    u16: number("NUMBER(5)"),
+    u32: number("NUMBER(10)"),
+    u64: {
+        bind(value) { return String(value); },
+        column: "NUMBER(20)",
+        unbind(value) { return BigInt(value); },
+    },
+    u128: {
+        bind(value) { return String(value); },
+        column: "VARCHAR2(40)",
+        unbind(value) { return BigInt(value); },
+    },
+    string: identity("VARCHAR2(4000)"),
+    time: identity("VARCHAR2(4000)"),
+    url: {
+        bind(value) { return value.toString(); },
+        column: "VARCHAR2(4000)",
+        unbind(value) { return new URL(value); },
+    },
+    uuid: identity("VARCHAR2(36)"),
+    uuid_v4: identity("VARCHAR2(36)"),
+    uuid_v7: identity("VARCHAR2(36)"),
+    json: {
+        bind(value) {
+            return { val: value, type: oracledb.DB_TYPE_JSON };
+        },
+        column: "JSON",
+        unbind(value) { return value; },
+    },
+};
+export default typemap;
+//# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import OracleDB from "#OracleDB";
+declare const _default: (config: typeof OracleDB.config) => OracleDB;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import OracleDB from "#OracleDB";
+export default (config) => new OracleDB(config);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@primate/oracledb",
+  "version": "0.1.0",
+  "description": "OracleDB databases for Primate",
+  "homepage": "https://primate.run/docs/database/oracledb",
+  "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/primate-run/primate",
+    "directory": "packages/oracledb"
+  },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
+  "devDependencies": {
+    "@rcompat/type": "^0.17.0",
+    "@types/oracledb": "^6.10.3"
+  },
+  "dependencies": {
+    "@rcompat/assert": "^0.13.0",
+    "@rcompat/is": "^0.11.0",
+    "oracledb": "^6.10.0",
+    "@primate/core": "^0.7.0",
+    "pema": "0.7.0"
+  },
+  "peerDependencies": {
+    "primate": "^0.38.0"
+  },
+  "imports": {
+    "#*": {
+      "@primate/source": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
+    }
+  },
+  "exports": {
+    ".": {
+      "@primate/source": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npm run db && npx proby",
+    "db": "scripts/db.sh"
+  }
+}