@primate/sqlite 0.6.0 → 0.8.0

package/lib/private/ColumnTypes.d.ts

@@ -1,12 +1,11 @@
-import type PrimitiveParam from "@rcompat/sqlite/PrimitiveParam";
-import type TypedArray from "@rcompat/type/TypedArray";
+import type { PrimitiveParam } from "@rcompat/sqlite";
+import type { TypedArray } from "@rcompat/type";
 type Validate<T extends {
     [K in keyof T]: PrimitiveParam;
 }> = T;
 type ColumnTypes = Validate<{
     BLOB: TypedArray;
     INTEGER: bigint | number;
-    "INTEGER PRIMARY KEY": number;
     NULL: null;
     REAL: number;
     TEXT: string;

package/lib/private/SQLite.d.ts

@@ -0,0 +1,42 @@
+import type { As, DataDict, DB, Schema, Sort, With } from "@primate/core/db";
+import type { Dict } from "@rcompat/type";
+declare const schema: import("pema").ObjectType<import("pema").NormalizeSchemaObject<{
+    readonly database: import("pema").DefaultType<import("pema").StringType, ":memory:">;
+}>, {
+    database: string;
+}>;
+export default class SQLite implements DB {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input, options?: {
+        debug?: boolean;
+    });
+    get explain(): Dict<{
+        query: string;
+        plans: string[];
+    }>;
+    get schema(): Schema;
+    create<O extends Dict>(as: As, record: Dict): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        where: DataDict;
+        with?: never;
+    }): Promise<number>;
+    read(as: As, args: {
+        where: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Sort;
+        with?: With;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        set: DataDict;
+        where: DataDict;
+    }): Promise<number>;
+    delete(as: As, args: {
+        where: DataDict;
+    }): Promise<number>;
+    close(): void;
+}
+export {};
+//# sourceMappingURL=SQLite.d.ts.map

package/lib/private/SQLite.js

@@ -0,0 +1,567 @@
+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 Client from "@rcompat/sqlite";
+import p from "pema";
+const BIND_BY = "$";
+const Q = sql.Q;
+const schema = p({ database: p.string.default(":memory:") });
+function like_to_glob(pattern) {
+    return pattern
+        .replace(/\\%/g, "<<PERCENT>>")
+        .replace(/\\_/g, "<<UNDERSCORE>>")
+        .replace(/\[/g, "<<LBRACKET>>")
+        .replace(/\]/g, "<<RBRACKET>>")
+        .replace(/\*/g, "[*]")
+        .replace(/\?/g, "[?]")
+        .replace(/%/g, "*")
+        .replace(/_/g, "?")
+        .replace(/<<PERCENT>>/g, "%")
+        .replace(/<<UNDERSCORE>>/g, "_")
+        .replace(/<<LBRACKET>>/g, "[[]")
+        .replace(/<<RBRACKET>>/g, "[]]");
+}
+function u_cmp(field, a, b, op) {
+    const la = `LENGTH(${a})`;
+    const lb = `LENGTH(${b})`;
+    switch (op) {
+        case ">":
+            return `${la}>${lb} OR (${la}=${lb} AND ${a}>${b})`;
+        case ">=":
+            return `${a}=${b} OR ${la}>${lb} OR (${la}=${lb} AND ${a}>${b})`;
+        case "<":
+            return `${la}<${lb} OR (${la}=${lb} AND ${a}<${b})`;
+        case "<=":
+            return `${a}=${b} OR ${la}<${lb} OR (${la}=${lb} AND ${a}<${b})`;
+        default:
+            throw E.operator_unknown(field, op);
+    }
+}
+function i_cmp(field, binding, op) {
+    const a = `CAST(${field} AS TEXT)`;
+    const b = `CAST(${binding} AS TEXT)`;
+    const a_neg = `(${a} LIKE '-%')`;
+    const b_neg = `(${b} LIKE '-%')`;
+    const a_abs = `CASE WHEN ${a_neg} THEN SUBSTR(${a}, 2) ELSE ${a} END`;
+    const b_abs = `CASE WHEN ${b_neg} THEN SUBSTR(${b}, 2) ELSE ${b} END`;
+    const is_gt = op === ">" || op === ">=";
+    const strict = op === ">" || op === "<";
+    const pos_neg_case = is_gt
+        ? `(${a_neg} = 0 AND ${b_neg} = 1)`
+        : `(${a_neg} = 1 AND ${b_neg} = 0)`;
+    const abs_op_positive = strict ? op : (is_gt ? ">" : "<");
+    const abs_op_negative = is_gt ? (strict ? "<" : "<=") : (strict ? ">" : ">=");
+    const same_sign = `(${a_neg} = ${b_neg} AND (` +
+        `(${a_neg} = 0 AND (${u_cmp(field, a, b, abs_op_positive)})) OR ` +
+        `(${a_neg} = 1 AND (${u_cmp(field, a_abs, b_abs, abs_op_negative)}))` +
+        "))";
+    const core = `${pos_neg_case} OR ${same_sign}`;
+    return strict ? `(${core})` : `(${a} = ${b} OR (${core}))`;
+}
+function cmp_expr(field, key, op, datatype) {
+    const rhs = `${BIND_BY}${key}`;
+    const sql_op = sql.OPS[op];
+    assert.defined(sql_op, E.operator_unknown(field, op));
+    if (base.BIGINT_STRING_TYPES.includes(datatype)) {
+        const cmp = base.UNSIGNED_BIGINT_TYPES.includes(datatype)
+            ? u_cmp(field, `CAST(${field} AS TEXT)`, `CAST(${rhs} AS TEXT)`, sql_op)
+            : i_cmp(field, rhs, sql_op);
+        return `(${cmp})`;
+    }
+    return `${field} ${sql_op} ${rhs}`;
+}
+function like(field, key, case_insensitive) {
+    const rhs = `${BIND_BY}${key}`;
+    if (case_insensitive)
+        return `LOWER(${field}) LIKE LOWER(${rhs})`;
+    return `CAST(${field} AS TEXT) GLOB ${rhs}`;
+}
+function get_column(key) {
+    return typemap[key].column;
+}
+function bind_one(key, value) {
+    return value === null ? null : typemap[key].bind(value);
+}
+function unbind_one(key, value) {
+    return typemap[key].unbind(value);
+}
+async function bind(types, fields) {
+    const out = {};
+    for (const [key, value] of Object.entries(fields)) {
+        const raw = key.startsWith("s_") ? key.slice(2) : key;
+        const type = types[raw.split("__")[0]];
+        if (is.dict(value) && type !== "json")
+            throw E.operator_scalar(key);
+        out[`${BIND_BY}${key}`] = await bind_one(type, value);
+    }
+    return out;
+}
+function unbind(types, row) {
+    return sql.unbind(types, row, unbind_one);
+}
+function columns_to_types(type) {
+    const t = type.toUpperCase();
+    if (t === "TEXT")
+        return [
+            "string", "url", "time", "datetime", "json",
+            "u64", "u128", "i64", "i128",
+            ...base.UUID_TYPES,
+        ];
+    if (t === "INTEGER")
+        return [
+            "boolean", "i8", "u8", "i16", "u16", "i32", "u32",
+        ];
+    if (t === "REAL")
+        return ["f32", "f64"];
+    if (t === "BLOB")
+        return ["blob"];
+    return [];
+}
+export default class SQLite {
+    #factory;
+    #client;
+    #debug = false;
+    #explain = {};
+    static config;
+    constructor(config, options) {
+        const parsed = schema.parse(config);
+        this.#factory = () => new Client(parsed.database, { safeIntegers: true });
+        this.#debug = options?.debug ?? false;
+    }
+    get #db() {
+        return this.#client ??= this.#factory();
+    }
+    #sql(query) {
+        return this.#db.prepare(query);
+    }
+    #query_all(as, query, binds) {
+        this.#capture(as.table, query, binds);
+        const rows = this.#sql(query).all(binds);
+        return rows.map(r => unbind(as.types, r));
+    }
+    #query_run(query, binds) {
+        return Number(this.#sql(query).run(binds).changes);
+    }
+    #capture(table, query, binds) {
+        if (!this.#debug)
+            return;
+        const rows = this.#sql(`EXPLAIN QUERY PLAN ${query}`).all(binds);
+        this.#explain[table] = { query, plans: rows.map(r => r.detail) };
+    }
+    get explain() {
+        return this.#explain;
+    }
+    get schema() {
+        return {
+            create: (table, pk, types) => {
+                const columns = [];
+                for (const [key, value] of Object.entries(types)) {
+                    const column_type = get_column(value);
+                    const column = `${sql.quote(key)} ${column_type}`;
+                    const is_int = column_type === "INTEGER";
+                    if (key === pk.name) {
+                        const generate = pk.generate && is_int ? " AUTOINCREMENT" : "";
+                        columns.push(`${column} PRIMARY KEY${generate}`);
+                    }
+                    else {
+                        columns.push(column);
+                    }
+                }
+                this.#sql(Q `CREATE TABLE IF NOT EXISTS ${table} (${columns})`).run();
+            },
+            delete: (table) => {
+                this.#sql(Q `DROP TABLE IF EXISTS ${table}`).run();
+            },
+            introspect: (table) => {
+                const rows = this.#sql(`PRAGMA table_info(${sql.quote(table)})`)
+                    .all();
+                if (rows.length === 0)
+                    return null;
+                const result = {};
+                for (const row of rows) {
+                    const candidates = columns_to_types(row.type);
+                    if (candidates.length > 0)
+                        result[row.name] = candidates;
+                }
+                return result;
+            },
+            alter: (table, diff) => {
+                const existing = this.schema.introspect(table);
+                if (existing === null)
+                    throw E.table_not_found(table);
+                for (const [from, to] of diff.rename) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            RENAME COLUMN ${[sql.quote(from)]} TO ${[sql.quote(to)]}`).run();
+                }
+                for (const field of diff.drop) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            DROP COLUMN ${[sql.quote(field)]}`).run();
+                }
+                for (const [field, type] of Object.entries(diff.add)) {
+                    this.#sql(Q `ALTER TABLE ${table}
+            ADD COLUMN ${[`${sql.quote(field)} ${get_column(type)}`]}`).run();
+                }
+            },
+        };
+    }
+    #where(types, where, alias) {
+        const fields = Object.keys(where);
+        if (fields.length === 0)
+            return "";
+        const parts = [];
+        for (const field of fields) {
+            const value = where[field];
+            const datatype = types[field];
+            const q = sql.quote(field);
+            const quoted = alias ? `${alias}.${q}` : q;
+            if (value === null) {
+                parts.push(`${quoted} IS NULL`);
+                continue;
+            }
+            if (is.dict(value)) {
+                const ops = Object.entries(value);
+                if (ops.length === 0)
+                    throw E.operator_empty(field);
+                for (const [op] of ops) {
+                    const bound_key = sql.bindKey(field, op);
+                    switch (op) {
+                        case "$like":
+                            parts.push(like(quoted, bound_key, false));
+                            break;
+                        case "$ilike":
+                            parts.push(like(quoted, bound_key, true));
+                            break;
+                        case "$ne":
+                            parts.push(`${quoted} != ${BIND_BY}${bound_key}`);
+                            break;
+                        case "$gt":
+                        case "$gte":
+                        case "$lt":
+                        case "$lte":
+                        case "$after":
+                        case "$before":
+                            parts.push(cmp_expr(quoted, bound_key, op, datatype));
+                            break;
+                        default:
+                            throw E.operator_unknown(field, op);
+                    }
+                }
+                continue;
+            }
+            parts.push(`${quoted} = ${BIND_BY}${field}`);
+        }
+        return `WHERE ${parts.join(" AND ")}`;
+    }
+    async #bind_where(types, where) {
+        const filtered = {};
+        for (const [field, value] of Object.entries(where)) {
+            if (value === null)
+                continue;
+            if (is.dict(value)) {
+                const ops = Object.entries(value);
+                for (const [op, op_value] of ops) {
+                    const bound_key = sql.bindKey(field, op);
+                    switch (op) {
+                        case "$like":
+                            filtered[bound_key] = like_to_glob(op_value);
+                            break;
+                        case "$ilike":
+                        case "$gte":
+                        case "$gt":
+                        case "$after":
+                        case "$lte":
+                        case "$lt":
+                        case "$before":
+                        case "$ne":
+                            filtered[bound_key] = op_value;
+                            break;
+                        default:
+                            throw E.operator_unknown(field, op);
+                    }
+                }
+                continue;
+            }
+            filtered[field] = value;
+        }
+        return bind(types, filtered);
+    }
+    #set(set) {
+        const columns = Object.keys(set);
+        if (columns.length === 0)
+            throw E.field_required("set");
+        return Q `SET ${columns.map(c => `${sql.quote(c)}=${BIND_BY}s_${c}`)}`;
+    }
+    async #bind_set(types, set) {
+        const columns = Object.keys(set);
+        if (columns.length === 0)
+            throw E.field_required("set");
+        const raw = Object.fromEntries(columns.map(c => [`s_${c}`, set[c]]));
+        return await bind(types, raw);
+    }
+    #generate_pk(as) {
+        const pk = as.pk;
+        const type = as.types[pk];
+        if (base.is_uuid_type(type))
+            return base.generate_uuid(type);
+        if (base.BIGINT_STRING_TYPES.includes(type)) {
+            const query = Q `SELECT ${pk} AS v
+        FROM ${as.table} ORDER BY LENGTH(${pk}) DESC, ${pk} DESC LIMIT 1`;
+            const rows = this.#sql(query).all();
+            return rows[0]?.v ? BigInt(rows[0].v) + 1n : 1n;
+        }
+        throw "unreachable";
+    }
+    #create(record) {
+        const fields = Object.keys(record);
+        return [
+            fields.map(sql.quote),
+            fields.map(field => `${BIND_BY}${field}`),
+        ];
+    }
+    async create(as, record) {
+        assert.dict(record);
+        const pk = as.pk;
+        const table = as.table;
+        // PK provided or none defined, simple insert
+        if (pk === null || pk in record) {
+            const [keys, values] = this.#create(record);
+            const query = keys.length > 0
+                ? Q `INSERT INTO ${as.table} (${keys}) VALUES (${values})`
+                : Q `INSERT INTO ${as.table} DEFAULT VALUES`;
+            this.#sql(query).run(await bind(as.types, record));
+            return record;
+        }
+        if (as.generate_pk === false)
+            throw E.pk_required(pk);
+        const type = as.types[pk];
+        // integer types, use RETURNING
+        if (!base.BIGINT_STRING_TYPES.includes(type) && !base.is_uuid_type(type)) {
+            const [keys, values] = this.#create(record);
+            const query = keys.length > 0
+                ? Q `INSERT INTO ${table} (${keys}) VALUES (${values}) RETURNING ${pk}`
+                : Q `INSERT INTO ${table} DEFAULT VALUES RETURNING ${pk}`;
+            const rows = this.#sql(query).all(await bind(as.types, record));
+            const pk_value = unbind_one(type, rows[0][pk]);
+            return { ...record, [pk]: pk_value };
+        }
+        // string or bigint, generate manually
+        const pk_value = this.#generate_pk(as);
+        const to_insert = { ...record, [pk]: pk_value };
+        const [keys, values] = this.#create(to_insert);
+        const query = Q `INSERT INTO ${table} (${keys}) VALUES (${values})`;
+        this.#sql(query).run(await bind(as.types, to_insert));
+        return to_insert;
+    }
+    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_base(as, args);
+    }
+    async #count(as, where) {
+        const WHERE = this.#where(as.types, where);
+        const binds = await this.#bind_where(as.types, where);
+        const table = as.table;
+        const query = `SELECT COUNT(*) AS n FROM ${sql.quote(table)} ${WHERE}`;
+        this.#capture(table, query, binds);
+        const rows = this.#sql(query).all(binds);
+        const length = rows.length;
+        assert.true(length === 1, E.record_number_invalid(length, "count"));
+        const n = rows[0].n;
+        assert.bigint(n, E.return_invalid(n, "bigint", "count"));
+        if (n > BigInt(Number.MAX_SAFE_INTEGER))
+            throw E.count_overflow(table, n);
+        return Number(n);
+    }
+    async #read_base(as, args) {
+        const query = this.#base_query(as, args);
+        const binds = await this.#bind_where(as.types, args.where);
+        return this.#query_all(as, query, binds);
+    }
+    async #read_phased(as, args) {
+        const fields = base.expand(as, args.fields, args.with);
+        const rows = await this.#read_base(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 reverse = assert.maybe.boolean(relation.reverse) ?? false;
+        const by = reverse ? relation.as.pk : relation.fk;
+        if (by === null)
+            throw E.relation_requires_pk("target");
+        const parent_by = reverse ? relation.fk : as.pk;
+        if (parent_by === null)
+            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];
+            grouped.set(key, grouped.get(key)?.concat(row) ?? [row]);
+        }
+        for (let i = 0; i < args.out.length; i++) {
+            const join_value = args.rows[i][parent_by];
+            if (join_value == null) {
+                args.out[i][args.table] = many;
+                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 in_binds = {};
+        const placeholders = [];
+        for (let i = 0; i < args.join_values.length; i++) {
+            const key = `${args.by}__in${i}`;
+            in_binds[key] = args.join_values[i];
+            placeholders.push(`${BIND_BY}${key}`);
+        }
+        const where = this.#where(args.as.types, args.where);
+        const where_part = where ? where.slice("WHERE ".length) : "";
+        const in_part = Q `${args.by} IN (${placeholders})`;
+        const where_parts = where_part
+            ? [`(${where_part})`, `(${in_part})`]
+            : [in_part];
+        const WHERE = `WHERE ${where_parts.join(" AND ")}`;
+        const all_columns = Object.keys(args.as.types);
+        const fields = args.fields !== undefined && args.fields.length > 0
+            ? args.fields
+            : all_columns;
+        const SELECT = sql.columns(args.as.types, base.fields(fields, args.by));
+        const base_order = `${sql.quote(args.by)} ASC`;
+        const user_order = sql.orderBy(args.as.types, args.sort)
+            .replace(/^ ORDER BY /, "");
+        const ORDER_BY = user_order
+            ? ` ORDER BY ${base_order}, ${user_order}`
+            : ` ORDER BY ${base_order}`;
+        const where_binds = await this.#bind_where(args.as.types, args.where);
+        const in_binds_bound = await bind(args.as.types, in_binds);
+        let query;
+        let binds;
+        const table = args.as.table;
+        if (per_parent !== undefined) {
+            const per_key = `${args.by}__limit__per_parent`;
+            query = `
+        WITH ranked AS (
+          SELECT
+            ${SELECT},
+            ROW_NUMBER() OVER (
+              PARTITION BY ${sql.quote(args.by)}
+              ${user_order ? `ORDER BY ${user_order}` : ""}
+            ) AS __rn
+          FROM ${sql.quote(table)}
+          ${WHERE}
+        )
+        SELECT ${SELECT}
+        FROM ranked
+        WHERE __rn <= ${BIND_BY}${per_key}
+        ${ORDER_BY}
+      `;
+            binds = {
+                ...where_binds, ...in_binds_bound,
+                [`${BIND_BY}${per_key}`]: per_parent,
+            };
+        }
+        else {
+            query = `SELECT ${SELECT} FROM ${sql.quote(table)} ${WHERE}${ORDER_BY}`;
+            binds = { ...where_binds, ...in_binds_bound };
+        }
+        return this.#query_all(args.as, query, binds);
+    }
+    #join(as, aliases, relation) {
+        const reverse = assert.maybe.boolean(relation.reverse) ?? false;
+        const parent_alias = aliases[as.table];
+        const alias = aliases[relation.as.table];
+        const table = sql.quote(relation.as.table);
+        const by = reverse ? relation.as.pk : relation.fk;
+        const parent_by = reverse ? relation.fk : as.pk;
+        if (by === null)
+            throw E.relation_requires_pk("target");
+        if (parent_by === null)
+            throw E.relation_requires_pk("parent");
+        const left = `${alias}.${sql.quote(by)}`;
+        const right = `${parent_alias}.${sql.quote(parent_by)}`;
+        return `LEFT JOIN ${table} ${alias} ON ${left} = ${right}`;
+    }
+    #base_query(as, args) {
+        const SELECT = sql.columns(as.types, args.fields);
+        const WHERE = this.#where(as.types, args.where);
+        const ORDER_BY = sql.orderBy(as.types, args.sort);
+        const LIMIT = sql.limit(args.limit);
+        const table = sql.quote(as.table);
+        return `SELECT ${SELECT} FROM ${table} ${WHERE}${ORDER_BY}${LIMIT}`;
+    }
+    async #read_joined(as, args) {
+        if (as.pk === null)
+            throw E.relation_requires_pk("parent");
+        const tables = [as.table, ...Object.values(args.with).map(r => r.as.table)];
+        const aliases = sql.aliases(tables);
+        const alias = aliases[as.table];
+        const fields = base.fields(args.fields, as.pk);
+        // subquery for limited parents
+        const SELECT = [
+            sql.aliased(aliases, as, fields),
+            ...Object.values(args.with).map(relation => {
+                return sql.aliased(aliases, relation.as, relation.as.pk !== null
+                    ? base.fields(relation.fields, relation.as.pk)
+                    : relation.fields);
+            }),
+        ].join(", ");
+        const SUBQUERY = `(${this.#base_query(as, { ...args, fields })})`;
+        const FROM = `${SUBQUERY} ${alias}`;
+        const JOINS = Object.values(args.with)
+            .map(relation => this.#join(as, aliases, relation))
+            .join("\n");
+        const ORDER_BY = sql.orderBy(as.types, args.sort, alias);
+        const query = `SELECT ${SELECT} FROM ${FROM} ${JOINS} ${ORDER_BY}`;
+        const binds = await this.#bind_where(as.types, args.where);
+        const rows = this.#sql(query).all(binds);
+        this.#capture(as.table, query, binds);
+        return sql.nest(as, { rows, aliases }, args, unbind_one);
+    }
+    async update(as, args) {
+        assert.nonempty(args.set);
+        assert.dict(args.where);
+        const WHERE = this.#where(as.types, args.where);
+        const where_binds = await this.#bind_where(as.types, args.where);
+        const SET = this.#set(args.set);
+        const set_binds = await this.#bind_set(as.types, args.set);
+        const query = `UPDATE ${sql.quote(as.table)} ${SET} ${WHERE}`;
+        return this.#query_run(query, { ...where_binds, ...set_binds });
+    }
+    async delete(as, args) {
+        assert.nonempty(args.where);
+        const WHERE = this.#where(as.types, args.where);
+        const query = `DELETE FROM ${sql.quote(as.table)} ${WHERE}`;
+        const binds = await this.#bind_where(as.types, args.where);
+        return this.#query_run(query, binds);
+    }
+    close() {
+        this.#db.close();
+    }
+}
+//# sourceMappingURL=SQLite.js.map

package/lib/private/typemap.d.ts

@@ -1,5 +1,5 @@
 import type ColumnTypes from "#ColumnTypes";
-import type TypeMap from "@primate/core/database/TypeMap";
+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

@@ -1,4 +1,3 @@
-import numeric from "@rcompat/is/numeric";
 function identity(column) {
     return {
         bind: value => value,
@@ -16,8 +15,7 @@ function number(column) {
 const typemap = {
     blob: {
         async bind(value) {
-            const arrayBuffer = await value.arrayBuffer();
-            return new Uint8Array(arrayBuffer);
+            return new Uint8Array(await value.arrayBuffer());
         },
         column: "BLOB",
         unbind(value) {
@@ -65,16 +63,13 @@ const typemap = {
         },
     },
     i8: number("INTEGER"),
-    primary: {
+    json: {
         bind(value) {
-            if (numeric(value)) {
-                return Number(value);
-            }
-            throw new Error(`\`${value}\` is not a valid primary key value`);
+            return JSON.stringify(value);
         },
-        column: "INTEGER PRIMARY KEY",
+        column: "TEXT",
         unbind(value) {
-            return String(value);
+            return JSON.parse(value);
         },
     },
     string: identity("TEXT"),
@@ -109,6 +104,9 @@ const typemap = {
             return new URL(value);
         },
     },
+    uuid: identity("TEXT"),
+    uuid_v4: identity("TEXT"),
+    uuid_v7: identity("TEXT"),
 };
 export default typemap;
 //# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

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

package/lib/public/index.js

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

package/package.json

@@ -1,41 +1,43 @@
 {
   "name": "@primate/sqlite",
-  "version": "0.6.0",
-  "description": "Primate SQLite database",
+  "version": "0.8.0",
+  "description": "SQLite databases for Primate",
   "homepage": "https://primate.run/docs/database/sqlite",
   "bugs": "https://github.com/primate-run/primate/issues",
+  "type": "module",
   "license": "MIT",
-  "files": [
-    "/lib/**/*.js",
-    "/lib/**/*.d.ts",
-    "!/**/*.spec.*"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/primate-run/primate",
     "directory": "packages/sqlite"
   },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
+  ],
   "dependencies": {
-    "@rcompat/assert": "^0.3.1",
-    "@rcompat/async": "^0.9.0",
-    "@rcompat/is": "^0.1.4",
-    "@rcompat/record": "^0.9.1",
-    "@rcompat/sqlite": "^0.4.0",
-    "@primate/core": "^0.4.0"
+    "@rcompat/assert": "^0.8.1",
+    "@rcompat/is": "^0.6.1",
+    "@rcompat/sqlite": "^0.11.1",
+    "@primate/core": "^0.6.0"
   },
   "devDependencies": {
-    "pema": "^0.4.0"
+    "@rcompat/type": "^0.11.1",
+    "pema": "^0.6.0"
+  },
+  "peerDependencies": {
+    "primate": "^0.37.0"
   },
-  "type": "module",
   "imports": {
     "#*": {
-      "apekit": "./src/private/*.ts",
+      "@primate/source": "./src/private/*.ts",
       "default": "./lib/private/*.js"
     }
   },
   "exports": {
     ".": {
-      "apekit": "./src/public/index.ts",
+      "@primate/source": "./src/public/index.ts",
       "default": "./lib/public/index.js"
     }
   },
@@ -43,8 +45,8 @@
     "build": "npm run clean && tsc",
     "clean": "rm -rf ./lib",
     "lint": "eslint .",
-    "test": "npm run build && npx proby",
-    "test:bun": "npm run build && bun x --bun proby",
-    "test:deno": "npm run build && deno run -A npm:proby"
+    "test": "npx proby",
+    "test:bun": "bunx --bun proby",
+    "test:deno": "deno run -A npm:proby"
   }
 }

package/lib/private/Database.d.ts

@@ -1,42 +0,0 @@
-import Database from "@primate/core/Database";
-import type As from "@primate/core/database/As";
-import type DataDict from "@primate/core/database/DataDict";
-import type TypeMap from "@primate/core/database/TypeMap";
-import type Dict from "@rcompat/type/Dict";
-import type StoreSchema from "pema/StoreSchema";
-declare const schema: import("pema").ObjectType<{
-    database: import("pema").DefaultType<import("pema/string").StringType, ":memory:">;
-}>;
-export default class SQLiteDatabase extends Database {
-    #private;
-    static config: typeof schema.input;
-    constructor(config?: typeof schema.input);
-    close(): void;
-    get typemap(): TypeMap<Dict>;
-    get schema(): {
-        create: (name: string, store: StoreSchema) => void;
-        delete: (name: string) => void;
-    };
-    create<O extends Dict>(as: As, args: {
-        record: DataDict;
-    }): Promise<O>;
-    read(as: As, args: {
-        count: true;
-        criteria: DataDict;
-    }): Promise<number>;
-    read(as: As, args: {
-        criteria: DataDict;
-        fields?: string[];
-        limit?: number;
-        sort?: Dict<"asc" | "desc">;
-    }): Promise<Dict[]>;
-    update(as: As, args: {
-        changes: DataDict;
-        criteria: DataDict;
-    }): Promise<number>;
-    delete(as: As, args: {
-        criteria: DataDict;
-    }): Promise<number>;
-}
-export {};
-//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -1,104 +0,0 @@
-import typemap from "#typemap";
-import Database from "@primate/core/Database";
-import assert from "@rcompat/assert";
-import Client from "@rcompat/sqlite";
-import pema from "pema";
-import string from "pema/string";
-const schema = pema({
-    database: string.default(":memory:"),
-});
-const options = { safeIntegers: true };
-export default class SQLiteDatabase extends Database {
-    #factory;
-    #client;
-    static config;
-    constructor(config) {
-        super("$");
-        const parsed = schema.parse(config);
-        this.#factory = () => new Client(parsed.database, options);
-    }
-    #get() {
-        if (this.#client === undefined) {
-            this.#client = this.#factory();
-        }
-        return this.#client;
-    }
-    close() {
-        this.#get().close();
-    }
-    get typemap() {
-        return typemap;
-    }
-    #new(name, store) {
-        const body = Object.entries(store)
-            .map(([key, value]) => `${this.ident(key)} ${this.column(value.datatype)}`)
-            .join(",");
-        const query = `CREATE TABLE IF NOT EXISTS ${this.ident(name)} (${body})`;
-        this.#get().prepare(query).run();
-    }
-    #drop(name) {
-        const query = `DROP TABLE IF EXISTS ${this.ident(name)}`;
-        this.#get().prepare(query).run();
-    }
-    get schema() {
-        return {
-            create: this.#new.bind(this),
-            delete: this.#drop.bind(this),
-        };
-    }
-    async create(as, args) {
-        const keys = Object.keys(args.record);
-        const columns = keys.map(k => this.ident(k));
-        const values = keys.map(key => `$${key}`).join(",");
-        const payload = columns.length > 0
-            ? `(${columns.join(",")}) VALUES (${values})`
-            : "DEFAULT VALUES";
-        const query = `INSERT INTO ${this.table(as)} ${payload} RETURNING id;`;
-        const binds = await this.bind(as.types, args.record);
-        const statement = this.#get().prepare(query);
-        const changes = statement.run(binds);
-        const id = BigInt(changes.lastInsertRowid);
-        return this.unbind(as.types, { ...args.record, id });
-    }
-    async read(as, args) {
-        const where = this.toWhere(as.types, args.criteria);
-        const binds = await this.bindCriteria(as.types, args.criteria);
-        if (args.count === true) {
-            const query = `SELECT COUNT(*) AS n FROM ${this.table(as)} ${where};`;
-            const [{ n }] = this.#get().prepare(query).all(binds);
-            return Number(n);
-        }
-        const select = this.toSelect(as.types, args.fields);
-        const sort = this.toSort(as.types, args.sort);
-        const limit = this.toLimit(args.limit);
-        const query = `SELECT
-      ${select} FROM ${this.table(as)} ${where}${sort}${limit};`;
-        const records = this.#get().prepare(query).all(binds);
-        return records.map(record => this.unbind(as.types, record));
-    }
-    async update(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
-        const where = this.toWhere(as.types, args.criteria);
-        const criteria = await this.bindCriteria(as.types, args.criteria);
-        const { set, binds: set_binds } = await this.toSet(as.types, args.changes);
-        const binds = { ...criteria, ...set_binds };
-        const query = `
-      WITH to_update AS (
-        SELECT id FROM ${this.table(as)}
-        ${where}
-      )
-      UPDATE ${this.table(as)}
-      ${set}
-      WHERE id IN (SELECT id FROM to_update)
-    `;
-        return Number(this.#get().prepare(`${query};`).run(binds).changes);
-    }
-    async delete(as, args) {
-        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
-        const where = this.toWhere(as.types, args.criteria);
-        const binds = await this.bindCriteria(as.types, args.criteria);
-        const query = `DELETE FROM ${this.table(as)} ${where}`;
-        return Number(this.#get().prepare(query).run(binds).changes);
-    }
-}
-//# sourceMappingURL=Database.js.map