@rwillians/exto 0.1.1 → 0.1.2

package/dist/cjs/standard-schema.js

@@ -0,0 +1,240 @@
+"use strict";
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                       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;
+/**
+ * @public  Thrown when a value fails validation, carrying every issue found.
+ * @since   0.1.0
+ * @version 1
+ */
+class ValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super('Failed validation:\n' + issues.map(issue => `  - ${formatPath(issue.path)}${issue.message}`).join('\n'));
+        this.issues = issues;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+const parse = (schema, value) => {
+    const parsed = schema['~standard'].validate(value);
+    if (parsed instanceof Promise) {
+        throw new Error('async standard schema validators are not supported');
+    }
+    return parsed;
+};
+exports.parse = parse;
+/**
+ * @public  Like {@link parse}, but returns the value or throws a
+ *          {@link ValidationError}.
+ * @since   0.1.0
+ * @version 1
+ */
+const parseOrThrow = (schema, value) => {
+    const parsed = (0, exports.parse)(schema, value);
+    if (parsed.issues)
+        throw new ValidationError(parsed.issues);
+    return parsed.value;
+};
+exports.parseOrThrow = parseOrThrow;
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                               UTILS                               //
+// // // // // // // // // // // // // // // // // // // // // // // //
+const formatPath = (path) => path && path.length > 0
+    ? path.map(segment => String(typeof segment === 'object' ? segment.key : segment)).join('.') + ': '
+    : '';
+const prependPath = (path) => (issue) => ({
+    ...issue,
+    path: [path, ...(issue.path ?? [])],
+});
+const define = (validate) => ({
+    '~standard': { version: 1, vendor: 'exto', validate },
+});
+const fail = (message) => ({ issues: [{ message }] });
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                        BUILT-IN VALIDATORS                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+const array = (schema) => define((input) => {
+    if (!Array.isArray(input))
+        return fail('must be an array');
+    const issues = [];
+    const value = [];
+    input.forEach((item, i) => {
+        const parsed = (0, exports.parse)(schema, item);
+        if (parsed.issues)
+            issues.push(...parsed.issues.map(prependPath(i)));
+        else
+            value.push(parsed.value);
+    });
+    return issues.length > 0
+        ? { issues }
+        : { value };
+});
+exports.array = array;
+/**
+ * @public  Defines a standard schema for bigints.
+ * @since   0.1.0
+ * @version 1
+ */
+const bigint = () => define((input) => typeof input === 'bigint'
+    ? { value: input }
+    : fail('must be a bigint'));
+exports.bigint = bigint;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+const boolean = () => define((input) => typeof input === 'boolean'
+    ? { value: input }
+    : fail('must be a boolean'));
+exports.boolean = boolean;
+/**
+ * @public  Defines a standard schema for dates, coercing ISO 8601 strings
+ *          and epoch timestamps (in milliseconds) into `Date`.
+ * @since   0.1.0
+ * @version 1
+ */
+const date = () => define((input) => {
+    const value = input instanceof Date ? input
+        : typeof input === 'string' || typeof input === 'number' ? new Date(input)
+            : undefined;
+    return value && !Number.isNaN(value.getTime())
+        ? { value }
+        : fail('must be a valid date, ISO 8601 string or epoch timestamp in milliseconds');
+});
+exports.date = date;
+/**
+ * @public  Defines a standard schema for one of the given string values.
+ * @since   0.1.0
+ * @version 1
+ */
+const enumOf = (values) => define((input) => values.includes(input)
+    ? { value: input }
+    : fail(`must be one of: ${values.join(', ')}`));
+exports.enumOf = enumOf;
+/**
+ * @public  Defines a standard schema for instances of a given class.
+ * @since   0.1.0
+ * @version 1
+ */
+const instanceOf = (ctor) => define((input) => input instanceof ctor
+    ? { value: input }
+    : fail(`must be an instance of ${ctor.name}`));
+exports.instanceOf = instanceOf;
+/**
+ * @public  Defines a standard schema for integers, within the safe integer
+ *          range by default.
+ * @since   0.1.0
+ * @version 1
+ */
+const integer = ({ min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER } = {}) => define((input) => {
+    if (!Number.isInteger(input))
+        return fail('must be an integer');
+    if (input < min)
+        return fail(`must be greater than or equal to ${min}`);
+    if (input > max)
+        return fail(`must be less than or equal to ${max}`);
+    return { value: input };
+});
+exports.integer = integer;
+/**
+ * @public  Defines a standard schema for calendar dates as `YYYY-MM-DD`
+ *          strings.
+ * @since   0.1.0
+ * @version 1
+ */
+const isoDate = () => define((input) => {
+    const valid = typeof input === 'string'
+        && /^\d{4}-\d{2}-\d{2}$/.test(input)
+        && new Date(`${input}T00:00:00Z`).toISOString().startsWith(input);
+    return valid
+        ? { value: input }
+        : fail('must be a valid date in the YYYY-MM-DD format');
+});
+exports.isoDate = isoDate;
+/**
+ * @public  Makes a given standard schema accept `null`.
+ * @since   0.1.0
+ * @version 1
+ */
+const nullable = (schema) => define((input) => input === null
+    ? { value: null }
+    : (0, exports.parse)(schema, input));
+exports.nullable = nullable;
+/**
+ * @public  Defines a standard schema for finite numbers.
+ * @since   0.1.0
+ * @version 1
+ */
+const number = () => define((input) => Number.isFinite(input)
+    ? { value: input }
+    : fail('must be a finite number'));
+exports.number = number;
+/**
+ * @public  Makes a given standard schema accept `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+const optional = (schema) => define((input) => input === undefined
+    ? { value: undefined }
+    : (0, exports.parse)(schema, input));
+exports.optional = optional;
+/**
+ * @public  Defines a standard schema for strings, optionally limited in
+ *          length.
+ * @since   0.1.0
+ * @version 1
+ */
+const string = ({ max } = {}) => define((input) => {
+    if (typeof input !== 'string')
+        return fail('must be a string');
+    if (max !== undefined && input.length > max)
+        return fail(`must be at most ${max} characters long`);
+    return { value: input };
+});
+exports.string = string;
+const strictObject = (shape) => define((input) => {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        return fail('must be an object');
+    const record = input;
+    const issues = Object
+        .keys(record)
+        .filter(key => !(key in shape))
+        .map(key => ({ path: [key], message: 'unknown field' }));
+    const value = {};
+    for (const [key, schema] of Object.entries(shape)) {
+        const parsed = (0, exports.parse)(schema, record[key]);
+        if (parsed.issues && record[key] === undefined)
+            issues.push({ path: [key], message: 'is required' });
+        else if (parsed.issues)
+            issues.push(...parsed.issues.map(prependPath(key)));
+        else if (parsed.value !== undefined)
+            value[key] = parsed.value;
+    }
+    return issues.length > 0
+        ? { issues }
+        : { value: value };
+});
+exports.strictObject = strictObject;
+/**
+ * @public  Defines a standard schema for UUID strings (any version).
+ * @since   0.1.0
+ * @version 1
+ */
+const uuid = () => define((input) => typeof input === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input)
+    ? { value: input }
+    : fail('must be a valid UUID'));
+exports.uuid = uuid;

package/dist/cjs/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.snakeCase = exports.camelCase = void 0;
+exports.raise = raise;
+const camelCase = (str) => str.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+exports.camelCase = camelCase;
+const snakeCase = (str) => str.replace(/[A-Z]/g, (char) => `_${char.toLowerCase()}`);
+exports.snakeCase = snakeCase;
+const wrap = (value) => Array.isArray(value)
+    ? value
+    : [value];
+exports.wrap = wrap;
+function raise(ctorOrMessage, messageOrCause, cause) {
+    if (typeof ctorOrMessage === 'string')
+        throw new Error(ctorOrMessage, { cause: messageOrCause });
+    throw new ctorOrMessage(messageOrCause, { cause });
+}

package/dist/esm/bun-postgres.js

@@ -0,0 +1,71 @@
+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',
+    FLOAT: () => 'DOUBLE PRECISION',
+    INTEGER: () => 'BIGINT',
+    JSON: () => 'JSONB',
+    SEQUENCE: () => 'BIGINT',
+    STRING: ({ length = 255 }) => `VARCHAR(${length})`,
+    TEXT: () => 'TEXT',
+    UUID: () => 'UUID',
+};
+const identity = () => ({
+    encode: (value) => value,
+    decode: (value) => value,
+});
+const dialect = {
+    name: 'postgres',
+    placeholder: (index) => `$${index}`,
+    type: (col) => TYPES[col.type](col),
+    generated: (col) => col.type === 'SEQUENCE'
+        ? 'GENERATED ALWAYS AS IDENTITY'
+        : undefined,
+    codecs: {
+        BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
+        BINARY: identity(),
+        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) },
+        JSON: identity(),
+        SEQUENCE: { encode: (value) => value, decode: (value) => Number(value) },
+        STRING: identity(),
+        TEXT: identity(),
+        UUID: identity(),
+    },
+};
+class BunPostgres {
+    sql;
+    loggers;
+    inTransaction;
+    dialect = dialect;
+    constructor(sql, loggers = [], inTransaction = false) {
+        this.sql = sql;
+        this.loggers = loggers;
+        this.inTransaction = inTransaction;
+    }
+    async execute(sql, params) {
+        return await this.sql.unsafe(sql, params);
+    }
+    async transaction(fn) {
+        const callback = (tx) => fn(new BunPostgres(tx, this.loggers, true));
+        const result = this.inTransaction
+            ? this.sql.savepoint(callback)
+            : this.sql.begin(callback);
+        return await result;
+    }
+}
+const connect = (url, { loggers = [] } = {}) => new BunPostgres(new SQL(url), loggers);
+export { connect, dialect, };

package/dist/esm/bun-sqlite.js

@@ -0,0 +1,90 @@
+import { Database } from 'bun:sqlite';
+const TYPES = {
+    BIGINT: 'INTEGER',
+    BINARY: 'BLOB',
+    BOOLEAN: 'INTEGER',
+    CITEXT: 'TEXT COLLATE NOCASE',
+    DATE: 'TEXT',
+    DATETIME: 'INTEGER',
+    DECIMAL: 'NUMERIC',
+    FLOAT: 'REAL',
+    INTEGER: 'INTEGER',
+    JSON: 'TEXT',
+    SEQUENCE: 'INTEGER',
+    STRING: 'TEXT',
+    TEXT: 'TEXT',
+    UUID: 'TEXT',
+};
+const identity = () => ({
+    encode: (value) => value,
+    decode: (value) => value,
+});
+// integers are read as bigints (see `execute`), so those that aren't BIGINT
+// columns go back to being numbers
+const numeric = {
+    encode: (value) => value,
+    decode: (value) => Number(value),
+};
+const dialect = {
+    name: 'sqlite',
+    placeholder: () => '?',
+    type: (col) => TYPES[col.type],
+    generated: (col) => {
+        if (col.type === 'SEQUENCE' && col.primaryKey)
+            return 'AUTOINCREMENT';
+        if (col.type === 'SEQUENCE')
+            throw new Error(`SQLite can only generate sequences for primary keys, column "${col.name}" isn't one`);
+        return undefined;
+    },
+    codecs: {
+        BIGINT: { encode: (value) => value, decode: (value) => BigInt(value) },
+        BINARY: identity(),
+        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,
+        JSON: { encode: (value) => JSON.stringify(value), decode: (value) => JSON.parse(value) },
+        SEQUENCE: numeric,
+        STRING: identity(),
+        TEXT: identity(),
+        UUID: identity(),
+    },
+};
+class BunSQLite {
+    conn;
+    loggers;
+    depth;
+    dialect = dialect;
+    constructor(conn, loggers = [], depth = 0) {
+        this.conn = conn;
+        this.loggers = loggers;
+        this.depth = depth;
+    }
+    async execute(sql, params) {
+        // without safe integers, bun:sqlite rounds anything beyond 2^53
+        return this.conn.prepare(sql).safeIntegers(true).all(...params);
+    }
+    // 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) {
+        const savepoint = `"sp_${this.depth}"`;
+        const [begin, commit, rollback] = this.depth === 0
+            ? ['BEGIN', 'COMMIT', 'ROLLBACK']
+            : [`SAVEPOINT ${savepoint}`, `RELEASE ${savepoint}`, `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}`];
+        this.conn.run(begin);
+        try {
+            const result = await fn(new BunSQLite(this.conn, this.loggers, this.depth + 1));
+            this.conn.run(commit);
+            return result;
+        }
+        catch (error) {
+            this.conn.run(rollback);
+            throw error;
+        }
+    }
+}
+const connect = (filename = ':memory:', { loggers = [] } = {}) => new BunSQLite(new Database(filename), loggers);
+export { connect, dialect, };