@rwillians/qx 0.1.2 → 0.1.3

package/dist/esm/standard-schema.d.ts

@@ -0,0 +1,157 @@
+import * as std from '@standard-schema/spec';
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export { type StandardSchemaV1 as Schema } from '@standard-schema/spec';
+/**
+ * @public  Infers the input type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type input<T extends std.StandardSchemaV1> = std.StandardSchemaV1.InferInput<T>;
+/**
+ * @public  Infers the Input type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type output<T extends std.StandardSchemaV1> = std.StandardSchemaV1.InferOutput<T>;
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const parse: <T extends std.StandardSchemaV1>(schema: T, value: unknown) => std.StandardSchemaV1.Result<output<T>>;
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxArray<T extends std.StandardSchemaV1> = std.StandardSchemaV1<input<T>[], output<T>[]>;
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const array: <T extends std.StandardSchemaV1>(schema: T) => QxArray<T>;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxBoolean = std.StandardSchemaV1<boolean, boolean>;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const boolean: () => QxBoolean;
+/**
+ * @public  Defines a standard schema for Date values that can be
+ *          coerced from ISO 8601 strings or epoch timestamps in
+ *          milliseconds.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxCoercibleDate = std.StandardSchemaV1<Date | string | number, Date>;
+/**
+ * @public  Defines a standard schema for Date values that can be
+ *          coerced from ISO 8601 strings or epoch timestamps in
+ *          milliseconds.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const date: () => QxCoercibleDate;
+/**
+ * @public  Defines a standard schema that validates instances of a
+ *          given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxInstanceOf<T> = std.StandardSchemaV1<T, T>;
+/**
+ * @public  Defines a standard schema that validates instances of a
+ *          given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const instanceOf: <T>(ctor: new (...args: any[]) => T) => QxInstanceOf<T>;
+/**
+ * @public  Defines a standard schema for integers with optional min
+ *          and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxInteger = std.StandardSchemaV1<number, number>;
+/**
+ * @public  Defines a standard schema for integers with optional min and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const integer: ({ min, max }?: {
+    min?: number;
+    max?: number;
+}) => QxInteger;
+/**
+ * @public  Makes any standard schema nullable.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxNullable<T extends std.StandardSchemaV1 = std.StandardSchemaV1> = std.StandardSchemaV1<input<T> | null, output<T> | null>;
+/**
+ * @public  Makes any standard schema accepts `null` as a valid value.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const nullable: <T extends std.StandardSchemaV1>(schema: T) => QxNullable<T>;
+/**
+ * @public  Defines a standard schema for numbers with optional min
+ *          and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxNumber = std.StandardSchemaV1<number, number>;
+/**
+ * @public  Defines a standard schema for numbers with optional min
+ *          and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const number: ({ min, max }?: {
+    min?: number;
+    max?: number;
+}) => QxNumber;
+/**
+ * @public  Defines an object schema that does not allow extra fields.
+ * @since   0.1.0
+ * @version 1
+ */
+type QxStrictObject<T extends Record<string, std.StandardSchemaV1>> = std.StandardSchemaV1<{
+    [K in keyof T]: input<T[K]>;
+}, {
+    [K in keyof T]: output<T[K]>;
+}>;
+/**
+ * @public  Defines an object schema that does not allow extra fields.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const strictObject: <T extends Record<string, std.StandardSchemaV1>>(shape: T) => QxStrictObject<T>;
+/**
+ * @public  Defines a standard schema for strings with optional min
+ *          and max length constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxString = std.StandardSchemaV1<string, string>;
+/**
+ * @public  Defines a standard schema for strings with optional min
+ *          and max length constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const string: ({ min, max }?: {
+    min?: number;
+    max?: number;
+}) => QxString;

package/dist/esm/standard-schema.js

@@ -0,0 +1,233 @@
+import * as std from '@standard-schema/spec';
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                        STANDARD SCHEMA API                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export {} from '@standard-schema/spec';
+/**
+ * @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;
+};
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                               UTILS                               //
+// // // // // // // // // // // // // // // // // // // // // // // //
+const prependPath = (path) => (issue) => ({
+    ...issue,
+    path: [path, ...(issue.path ?? [])],
+});
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export const array = (schema) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (!Array.isArray(input)) {
+                return { issues: [{ message: 'must be an array' }] };
+            }
+            const issues = [];
+            const value = [];
+            for (let i = 0; i < input.length; i++) {
+                const parsed = parse(schema, input[i]);
+                parsed.issues
+                    ? issues.push(...parsed.issues.map(prependPath(i)))
+                    : value.push(parsed.value);
+            }
+            return issues.length > 0
+                ? { issues }
+                : { value: value };
+        },
+    },
+});
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export const boolean = () => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => typeof input !== 'boolean'
+            ? { issues: [{ message: 'must be a boolean' }] }
+            : { value: input },
+    },
+});
+/**
+ * @public  Defines a standard schema for Date values that can be
+ *          coerced from ISO 8601 strings or epoch timestamps in
+ *          milliseconds.
+ * @since   0.1.0
+ * @version 1
+ */
+export const date = () => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (input instanceof Date)
+                return isNaN(input.getTime())
+                    ? { issues: [{ message: 'must be a valid date' }] }
+                    : { value: input };
+            if (typeof input !== 'string' &&
+                typeof input !== 'number')
+                return { issues: [{ message: 'must be a valid ISO 8601 string or epoch timestamp in milliseconds' }] };
+            const date = new Date(input);
+            if (isNaN(date.getTime()))
+                return { issues: [{ message: 'must be a valid ISO 8601 string or epoch timestamp in milliseconds' }] };
+            return { value: date };
+        },
+    },
+});
+/**
+ * @public  Defines a standard schema that validates instances of a
+ *          given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export const instanceOf = (ctor) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => !(input instanceof ctor)
+            ? { issues: [{ message: `must be an instance of ${ctor.name}` }] }
+            : { value: input },
+    },
+});
+/**
+ * @public  Defines a standard schema for integers with optional min and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export const integer = ({ min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER } = {}) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (typeof input !== 'number')
+                return { issues: [{ message: 'must be a integer' }] };
+            if (Number.isNaN(input) || !Number.isFinite(input))
+                return { issues: [{ message: 'must be a integer' }] };
+            if (!Number.isInteger(input))
+                return { issues: [{ message: 'must be a integer' }] };
+            if (input < min)
+                return { issues: [{ message: `must be greater than or equal to ${min}` }] };
+            if (input > max)
+                return { issues: [{ message: `must be less than or equal to ${max}` }] };
+            return { value: input };
+        },
+    },
+});
+/**
+ * @public  Makes any standard schema accepts `null` as a valid value.
+ * @since   0.1.0
+ * @version 1
+ */
+export const nullable = (schema) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (value) => value === null
+            ? { value }
+            : parse(schema, value),
+    },
+});
+/**
+ * @public  Defines a standard schema for numbers with optional min
+ *          and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export const number = ({ min = Number.MIN_VALUE, max = Number.MAX_VALUE } = {}) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (typeof input !== 'number')
+                return { issues: [{ message: 'must be a number' }] };
+            if (Number.isNaN(input) || !Number.isFinite(input))
+                return { issues: [{ message: 'must be a number' }] };
+            if (input < min)
+                return { issues: [{ message: `must be greater than or equal to ${min}` }] };
+            if (input > max)
+                return { issues: [{ message: `must be less than or equal to ${max}` }] };
+            return { value: input };
+        },
+    },
+});
+/**
+ * @public  Defines an object schema that does not allow extra fields.
+ * @since   0.1.0
+ * @version 1
+ */
+export const strictObject = (shape) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (typeof input !== 'object' || input === null) {
+                return { issues: [{ message: 'must be an object' }] };
+            }
+            const issues = [];
+            const inputKeys = new Set(Object.keys(input));
+            const shapeKeys = new Set(Object.keys(shape));
+            // one issue for each key of `input` that doesn't exist in `shape`
+            for (const key of inputKeys.difference(shapeKeys)) {
+                issues.push({ path: [key], message: 'unknown field' });
+            }
+            // one issue for each key of `shape` that doesn't exist in `input`
+            for (const key of shapeKeys.difference(inputKeys)) {
+                issues.push({ path: [key], message: 'is required' });
+            }
+            const record = {};
+            for (const [key, value] of Object.entries(input)) {
+                const parsed = shape[key]['~standard'].validate(value);
+                if (parsed instanceof Promise) {
+                    throw new Error('async validators are not supported');
+                }
+                parsed.issues
+                    ? issues.push(...parsed.issues.map(prependPath(key)))
+                    : record[key] = parsed.value;
+            }
+            return issues.length > 0
+                ? { issues }
+                : { value: record };
+        },
+    },
+});
+/**
+ * @public  Defines a standard schema for strings with optional min
+ *          and max length constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+export const string = ({ min, max } = {}) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => {
+            if (typeof input !== 'string')
+                return { issues: [{ message: 'must be a string' }] };
+            if (min !== undefined && input.length < min)
+                return { issues: [{ message: `must be at least ${min} characters long` }] };
+            if (max !== undefined && input.length > max)
+                return { issues: [{ message: `must be at most ${max} characters long` }] };
+            return { value: input };
+        },
+    },
+});

package/dist/esm/utils.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @private Converts a snake_case string to camelCase.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const camelCase: (str: string) => string;
+/**
+   * @private Simplified check for plain objects.
+   * @since   0.1.0
+   * @version 1
+   */
+export declare const isPlainObject: (value: unknown) => value is Record<string, any>;
+/**
+   * @private Throws an error if the given number is greater than the
+   *          specified maximum.
+   * @since   0.1.0
+   * @version 1
+   */
+export declare const lte: (n: number, max: number) => number;
+/**
+ * @public  Maps over the keys of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const mapKeys: <T extends Record<string, any>, U extends string>(obj: T, fn: (key: keyof T) => U) => { [K in U]: T[keyof T]; };
+/**
+ * @private Maps over the values of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const mapValues: <T extends Record<string, any>, U>(obj: T, fn: (value: T[keyof T], key: keyof T) => U) => { [K in keyof T]: U; };
+/**
+   * @private Resolves the given value or function to a value.
+   * @since   0.1.0
+   * @version 1
+   */
+export declare const resolve: <T>(value: T | (() => T)) => T;
+/**
+ * @private Converts a camelCase string to snake_case.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const snakeCase: (str: string) => string;
+/**
+   * @public  Wraps the given value in an array, unless it's already an
+   *          array.
+   * @since   0.1.0
+   * @version 1
+   */
+export declare const wrap: <T>(value: T | T[]) => T[];

package/dist/esm/utils.js

@@ -0,0 +1,65 @@
+/**
+ * @private Converts a snake_case string to camelCase.
+ * @since   0.1.0
+ * @version 1
+ */
+export const camelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+/**
+   * @private Simplified check for plain objects.
+   * @since   0.1.0
+   * @version 1
+   */
+export const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    let proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return true;
+    return proto === Object.prototype;
+};
+/**
+   * @private Throws an error if the given number is greater than the
+   *          specified maximum.
+   * @since   0.1.0
+   * @version 1
+   */
+export const lte = (n, max) => {
+    if (n > max)
+        throw new Error(`Must be at most ${max}, got ${n}`);
+    return n;
+};
+/**
+ * @public  Maps over the keys of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+export const mapKeys = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([key, value]) => [fn(key), value]));
+/**
+ * @private Maps over the values of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+export const mapValues = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
+/**
+   * @private Resolves the given value or function to a value.
+   * @since   0.1.0
+   * @version 1
+   */
+export const resolve = (value) => typeof value === 'function'
+    ? value()
+    : value;
+/**
+ * @private Converts a camelCase string to snake_case.
+ * @since   0.1.0
+ * @version 1
+ */
+export const snakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+/**
+   * @public  Wraps the given value in an array, unless it's already an
+   *          array.
+   * @since   0.1.0
+   * @version 1
+   */
+export const wrap = (value) => Array.isArray(value)
+    ? value
+    : [value];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/qx",
   "description": "A teeny tiny ORM for SQLite.",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Rafael Willians <me@rwillians.com>",
   "license": "MIT",
   "repository": {