@rwillians/exto 0.1.2 → 0.2.0

package/dist/cjs/standard-schema.js

@@ -3,7 +3,7 @@
 //                       STANDARD SCHEMA SPEC                        //
 // // // // // // // // // // // // // // // // // // // // // // // //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uuid = exports.strictObject = exports.string = exports.optional = exports.number = exports.nullable = exports.isoDate = exports.integer = exports.instanceOf = exports.enumOf = exports.date = exports.boolean = exports.bigint = exports.array = exports.parseOrThrow = exports.parse = exports.ValidationError = void 0;
+exports.uuid = exports.strictObject = exports.string = exports.record = exports.optional = exports.number = exports.nullable = exports.isoDate = exports.integer = exports.instanceOf = exports.enumOf = exports.date = exports.boolean = exports.bigint = exports.array = exports.parseOrThrow = exports.parse = exports.ValidationError = void 0;
 /**
  * @public  Thrown when a value fails validation, carrying every issue found.
  * @since   0.1.0
@@ -192,6 +192,15 @@ const optional = (schema) => define((input) => input === undefined
     ? { value: undefined }
     : (0, exports.parse)(schema, input));
 exports.optional = optional;
+/**
+ * @public  Defines a standard schema for plain objects with string keys.
+ * @since   0.2.0
+ * @version 1
+ */
+const record = () => define((input) => typeof input === 'object' && input !== null && Object.getPrototypeOf(input) === Object.prototype
+    ? { value: input }
+    : fail('must be a plain object'));
+exports.record = record;
 /**
  * @public  Defines a standard schema for strings, optionally limited in
  *          length.

package/dist/esm/bun-postgres.js

@@ -1,27 +1,47 @@
 import { SQL } from 'bun';
-import { raise } from './utils';
 const TYPES = {
     BIGINT: () => 'BIGINT',
     BINARY: () => 'BYTEA',
     BOOLEAN: () => 'BOOLEAN',
     CITEXT: () => 'CITEXT',
     DATE: () => 'DATE',
-    DATETIME: () => 'TIMESTAMPTZ',
-    DECIMAL: ({ precision, scale }) => [precision, scale].every(Number.isInteger) ? `NUMERIC(${precision}, ${scale})`
-        : [precision, scale].some(Number.isInteger) ? raise('precision and scale are mutually inclusive, either you provide both or neither')
-            : 'NUMERIC',
+    DECIMAL: ({ precision, scale }) => precision !== undefined && scale !== undefined ? `NUMERIC(${precision}, ${scale})` : 'NUMERIC',
     FLOAT: () => 'DOUBLE PRECISION',
     INTEGER: () => 'BIGINT',
     JSON: () => 'JSONB',
     SEQUENCE: () => 'BIGINT',
     STRING: ({ length = 255 }) => `VARCHAR(${length})`,
     TEXT: () => 'TEXT',
+    TIMESTAMP: () => 'TIMESTAMPTZ',
     UUID: () => 'UUID',
 };
 const identity = () => ({
     encode: (value) => value,
     decode: (value) => value,
 });
+// Bun.SQL reads bigints (BIGINT columns, COUNT and SUM) and NUMERICs as
+// strings
+const numeric = {
+    encode: (value) => value,
+    decode: (value) => Number(value),
+};
+// `#>>` reads text, so fields of other types are cast back to theirs
+const CASTS = {
+    BIGINT: 'BIGINT',
+    BOOLEAN: 'BOOLEAN',
+    DECIMAL: 'NUMERIC',
+    FLOAT: 'DOUBLE PRECISION',
+    INTEGER: 'DOUBLE PRECISION',
+    SEQUENCE: 'BIGINT',
+};
+const jsonPath = (path) => `'{${path.map(key => `"${key.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\'', '\'\'')}"`).join(',')}}'`;
+const json = (sql, path, type) => {
+    if (type === 'JSON')
+        return `${sql} #> ${jsonPath(path)}`;
+    const text = `${sql} #>> ${jsonPath(path)}`;
+    return CASTS[type] ? `(${text})::${CASTS[type]}` : text;
+};
+// Bun.SQL sends objects and arrays as JSON, and reads JSONB already parsed
 const dialect = {
     name: 'postgres',
     placeholder: (index) => `$${index}`,
@@ -29,20 +49,21 @@ const dialect = {
     generated: (col) => col.type === 'SEQUENCE'
         ? 'GENERATED ALWAYS AS IDENTITY'
         : undefined,
+    json,
     codecs: {
         BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
-        BINARY: identity(),
+        BINARY: { encode: (value) => value, decode: (value) => new Uint8Array(value) },
         BOOLEAN: identity(),
         CITEXT: identity(),
         DATE: { encode: (value) => value, decode: (value) => value instanceof Date ? value.toISOString().slice(0, 10) : value },
-        DATETIME: identity(),
-        DECIMAL: { encode: (value) => value, decode: (value) => Number(value) },
-        FLOAT: identity(),
-        INTEGER: { encode: (value) => value, decode: (value) => Number(value) },
+        DECIMAL: numeric,
+        FLOAT: numeric,
+        INTEGER: numeric,
         JSON: identity(),
-        SEQUENCE: { encode: (value) => value, decode: (value) => Number(value) },
+        SEQUENCE: numeric,
         STRING: identity(),
         TEXT: identity(),
+        TIMESTAMP: { encode: (value) => value, decode: (value) => new Date(value) },
         UUID: identity(),
     },
 };
@@ -59,6 +80,10 @@ class BunPostgres {
     async execute(sql, params) {
         return await this.sql.unsafe(sql, params);
     }
+    async close() {
+        await this.sql.close();
+    }
+    // nested transactions are savepoints of the outer one
     async transaction(fn) {
         const callback = (tx) => fn(new BunPostgres(tx, this.loggers, true));
         const result = this.inTransaction

package/dist/esm/bun-sqlite.js

@@ -5,7 +5,6 @@ const TYPES = {
     BOOLEAN: 'INTEGER',
     CITEXT: 'TEXT COLLATE NOCASE',
     DATE: 'TEXT',
-    DATETIME: 'INTEGER',
     DECIMAL: 'NUMERIC',
     FLOAT: 'REAL',
     INTEGER: 'INTEGER',
@@ -13,6 +12,7 @@ const TYPES = {
     SEQUENCE: 'INTEGER',
     STRING: 'TEXT',
     TEXT: 'TEXT',
+    TIMESTAMP: 'INTEGER',
     UUID: 'TEXT',
 };
 const identity = () => ({
@@ -25,6 +25,8 @@ const numeric = {
     encode: (value) => value,
     decode: (value) => Number(value),
 };
+// sqlite's JSON paths quote each key, so that any key is a valid one
+const jsonPath = (path) => `'$${path.map(key => `."${key.replaceAll('"', '\\"').replaceAll('\'', '\'\'')}"`).join('')}'`;
 const dialect = {
     name: 'sqlite',
     placeholder: () => '?',
@@ -36,13 +38,13 @@ const dialect = {
             throw new Error(`SQLite can only generate sequences for primary keys, column "${col.name}" isn't one`);
         return undefined;
     },
+    json: (sql, path, type) => `${sql} ${type === 'JSON' ? '->' : '->>'} ${jsonPath(path)}`,
     codecs: {
         BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
-        BINARY: identity(),
+        BINARY: { encode: (value) => value, decode: (value) => new Uint8Array(value) },
         BOOLEAN: { encode: (value) => (value ? 1 : 0), decode: (value) => Number(value) === 1 },
         CITEXT: identity(),
         DATE: identity(),
-        DATETIME: { encode: (value) => value.getTime(), decode: (value) => new Date(Number(value)) },
         DECIMAL: numeric,
         FLOAT: numeric,
         INTEGER: numeric,
@@ -50,6 +52,7 @@ const dialect = {
         SEQUENCE: numeric,
         STRING: identity(),
         TEXT: identity(),
+        TIMESTAMP: { encode: (value) => value.getTime(), decode: (value) => new Date(Number(value)) },
         UUID: identity(),
     },
 };
@@ -67,6 +70,9 @@ class BunSQLite {
         // without safe integers, bun:sqlite rounds anything beyond 2^53
         return this.conn.prepare(sql).safeIntegers(true).all(...params);
     }
+    async close() {
+        this.conn.close();
+    }
     // bun:sqlite's own `transaction()` is synchronous and would commit before an
     // async callback settles, hence the manual BEGIN/COMMIT (SAVEPOINT if nested)
     async transaction(fn) {