@rwillians/exto 0.1.1 → 0.2.0

package/dist/esm/standard-schema.js

@@ -0,0 +1,237 @@
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                       STANDARD SCHEMA SPEC                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                        STANDARD SCHEMA API                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export {};
+/**
+ * @public  Thrown when a value fails validation, carrying every issue found.
+ * @since   0.1.0
+ * @version 1
+ */
+export 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';
+    }
+}
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+export 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;
+};
+/**
+ * @public  Like {@link parse}, but returns the value or throws a
+ *          {@link ValidationError}.
+ * @since   0.1.0
+ * @version 1
+ */
+export const parseOrThrow = (schema, value) => {
+    const parsed = parse(schema, value);
+    if (parsed.issues)
+        throw new ValidationError(parsed.issues);
+    return parsed.value;
+};
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                               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
+ */
+export 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 = parse(schema, item);
+        if (parsed.issues)
+            issues.push(...parsed.issues.map(prependPath(i)));
+        else
+            value.push(parsed.value);
+    });
+    return issues.length > 0
+        ? { issues }
+        : { value };
+});
+/**
+ * @public  Defines a standard schema for bigints.
+ * @since   0.1.0
+ * @version 1
+ */
+export const bigint = () => define((input) => typeof input === 'bigint'
+    ? { value: input }
+    : fail('must be a bigint'));
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export const boolean = () => define((input) => typeof input === 'boolean'
+    ? { value: input }
+    : fail('must be a 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
+ */
+export 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');
+});
+/**
+ * @public  Defines a standard schema for one of the given string values.
+ * @since   0.1.0
+ * @version 1
+ */
+export const enumOf = (values) => define((input) => values.includes(input)
+    ? { value: input }
+    : fail(`must be one of: ${values.join(', ')}`));
+/**
+ * @public  Defines a standard schema for instances of a given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export const instanceOf = (ctor) => define((input) => input instanceof ctor
+    ? { value: input }
+    : fail(`must be an instance of ${ctor.name}`));
+/**
+ * @public  Defines a standard schema for integers, within the safe integer
+ *          range by default.
+ * @since   0.1.0
+ * @version 1
+ */
+export 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 };
+});
+/**
+ * @public  Defines a standard schema for calendar dates as `YYYY-MM-DD`
+ *          strings.
+ * @since   0.1.0
+ * @version 1
+ */
+export 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');
+});
+/**
+ * @public  Makes a given standard schema accept `null`.
+ * @since   0.1.0
+ * @version 1
+ */
+export const nullable = (schema) => define((input) => input === null
+    ? { value: null }
+    : parse(schema, input));
+/**
+ * @public  Defines a standard schema for finite numbers.
+ * @since   0.1.0
+ * @version 1
+ */
+export const number = () => define((input) => Number.isFinite(input)
+    ? { value: input }
+    : fail('must be a finite number'));
+/**
+ * @public  Makes a given standard schema accept `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+export const optional = (schema) => define((input) => input === undefined
+    ? { value: undefined }
+    : parse(schema, input));
+/**
+ * @public  Defines a standard schema for plain objects with string keys.
+ * @since   0.2.0
+ * @version 1
+ */
+export const record = () => define((input) => typeof input === 'object' && input !== null && Object.getPrototypeOf(input) === Object.prototype
+    ? { value: input }
+    : fail('must be a plain object'));
+/**
+ * @public  Defines a standard schema for strings, optionally limited in
+ *          length.
+ * @since   0.1.0
+ * @version 1
+ */
+export 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 };
+});
+export 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 = 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 };
+});
+/**
+ * @public  Defines a standard schema for UUID strings (any version).
+ * @since   0.1.0
+ * @version 1
+ */
+export 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'));

package/dist/esm/utils.js

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

package/dist/types/bun-postgres.d.ts

@@ -0,0 +1,17 @@
+import { SQL } from 'bun';
+import type { Dialect, IDatabase, ILogger, Row } from './index';
+declare const dialect: Dialect;
+declare class BunPostgres implements IDatabase {
+    private readonly sql;
+    readonly loggers: ILogger[];
+    private readonly inTransaction;
+    readonly dialect: Dialect;
+    constructor(sql: SQL, loggers?: ILogger[], inTransaction?: boolean);
+    execute(sql: string, params: unknown[]): Promise<Row[] & SQL.ResultMetadata>;
+    close(): Promise<void>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const connect: (url: string, { loggers }?: {
+    loggers?: ILogger[];
+}) => BunPostgres;
+export { connect, dialect, };

package/dist/types/bun-sqlite.d.ts

@@ -0,0 +1,17 @@
+import { Database } from 'bun:sqlite';
+import type { Dialect, IDatabase, ILogger, Row } from './index';
+declare const dialect: Dialect;
+declare class BunSQLite implements IDatabase {
+    private readonly conn;
+    readonly loggers: ILogger[];
+    private readonly depth;
+    readonly dialect: Dialect;
+    constructor(conn: Database, loggers?: ILogger[], depth?: number);
+    execute(sql: string, params: unknown[]): Promise<Row[]>;
+    close(): Promise<void>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const connect: (filename?: string, { loggers }?: {
+    loggers?: ILogger[];
+}) => BunSQLite;
+export { connect, dialect, };