@rwillians/qx 0.1.20 → 0.2.0

package/dist/cjs/standard-schema.js

@@ -0,0 +1,239 @@
+"use strict";
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                       STANDARD SCHEMA SPEC                        //
+// // // // // // // // // // // // // // // // // // // // // // // //
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.strictObject = exports.number = exports.nullable = exports.integer = exports.instanceOf = exports.date = exports.boolean = exports.array = exports.parse = void 0;
+/**
+ * @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;
+// // // // // // // // // // // // // // // // // // // // // // // //
+//                               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
+ */
+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 = (0, exports.parse)(schema, input[i]);
+                parsed.issues
+                    ? issues.push(...parsed.issues.map(prependPath(i)))
+                    : value.push(parsed.value);
+            }
+            return issues.length > 0
+                ? { issues }
+                : { value: value };
+        },
+    },
+});
+exports.array = array;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+const boolean = () => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => typeof input !== 'boolean'
+            ? { issues: [{ message: 'must be a boolean' }] }
+            : { value: input },
+    },
+});
+exports.boolean = boolean;
+/**
+ * @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
+ */
+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 };
+        },
+    },
+});
+exports.date = date;
+/**
+ * @public  Defines a standard schema that validates instances of a
+ *          given class.
+ * @since   0.1.0
+ * @version 1
+ */
+const instanceOf = (ctor) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (input) => !(input instanceof ctor)
+            ? { issues: [{ message: `must be an instance of ${ctor.name}` }] }
+            : { value: input },
+    },
+});
+exports.instanceOf = instanceOf;
+/**
+ * @public  Defines a standard schema for integers with optional min and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+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 };
+        },
+    },
+});
+exports.integer = integer;
+/**
+ * @public  Makes any standard schema accepts `null` as a valid value.
+ * @since   0.1.0
+ * @version 1
+ */
+const nullable = (schema) => ({
+    '~standard': {
+        version: 1,
+        vendor: 'qx',
+        validate: (value) => value === null
+            ? { value }
+            : (0, exports.parse)(schema, value),
+    },
+});
+exports.nullable = nullable;
+/**
+ * @public  Defines a standard schema for numbers with optional min
+ *          and max constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+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 };
+        },
+    },
+});
+exports.number = number;
+/**
+ * @public  Defines an object schema that does not allow extra fields.
+ * @since   0.1.0
+ * @version 1
+ */
+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 };
+        },
+    },
+});
+exports.strictObject = strictObject;
+/**
+ * @public  Defines a standard schema for strings with optional min
+ *          and max length constraints.
+ * @since   0.1.0
+ * @version 1
+ */
+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 };
+        },
+    },
+});
+exports.string = string;

package/dist/cjs/utils.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.snakeCase = exports.resolve = exports.mapValues = exports.mapKeys = exports.lte = exports.keys = exports.isPlainObject = exports.entries = exports.camelCase = void 0;
+/**
+ * @private Converts a snake_case string to camelCase.
+ * @since   0.1.0
+ * @version 2
+ */
+const camelCase = (str) => str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+exports.camelCase = camelCase;
+/**
+ * @private Same as {@link Object.prototype.entries} but with better
+ *          types.
+ * @since   0.1.17
+ * @version 1
+ */
+const entries = (obj) => Object.entries(obj);
+exports.entries = entries;
+/**
+   * @private Simplified check for plain objects.
+   * @since   0.1.0
+   * @version 1
+   */
+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;
+};
+exports.isPlainObject = isPlainObject;
+/**
+ * @private Same as {@link Object.prototype.keys} but with better
+ *          types.
+ * @since   0.1.17
+ * @version 1
+ */
+const keys = (obj) => Object.keys(obj);
+exports.keys = keys;
+/**
+   * @private Throws an error if the given number is greater than the
+   *          specified maximum.
+   * @since   0.1.0
+   * @version 1
+   */
+const lte = (n, max) => {
+    if (n > max)
+        throw new Error(`Must be at most ${max}, got ${n}`);
+    return n;
+};
+exports.lte = lte;
+/**
+ * @public  Maps over the keys of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+const mapKeys = (obj, fn) => Object.fromEntries((0, exports.entries)(obj).map(([key, value]) => [fn(key), value]));
+exports.mapKeys = mapKeys;
+/**
+ * @private Maps over the values of an object.
+ * @since   0.1.0
+ * @version 1
+ */
+const mapValues = (obj, fn) => Object.fromEntries((0, exports.entries)(obj).map(([key, value]) => [key, fn(value, key)]));
+exports.mapValues = mapValues;
+/**
+   * @private Resolves the given value or function to a value.
+   * @since   0.1.0
+   * @version 1
+   */
+const resolve = (value) => typeof value === 'function'
+    ? value()
+    : value;
+exports.resolve = resolve;
+/**
+ * @private Converts a camelCase string to snake_case.
+ * @since   0.1.0
+ * @version 1
+ */
+const snakeCase = (str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+exports.snakeCase = snakeCase;
+/**
+   * @public  Wraps the given value in an array, unless it's already an
+   *          array.
+   * @since   0.1.0
+   * @version 1
+   */
+const wrap = (value) => Array.isArray(value)
+    ? value
+    : [value];
+exports.wrap = wrap;

package/dist/esm/adapter.js

@@ -0,0 +1,23 @@
+import {} from './index';
+import * as u from './utils';
+/**
+ * @public  Wraps a function call that executes DDL with logging
+ *          capabilities.
+ *
+ *          A `debug` log is emitted before the function is executed,
+ *          and an `error` log if the function throws an error. After
+ *          logging, the error is re-thrown.
+ * @since   0.1.17
+ * @version 1
+ */
+export const withLoggedQuery = async (logger, data, fn) => {
+    const loggers = u.wrap(logger);
+    const { sql, params } = data;
+    loggers.forEach(logger => logger.debug(sql, params));
+    return Promise.resolve().then(() => fn(sql, params)).catch(error => {
+        loggers.forEach(logger => logger.error(sql, params, error));
+        return Promise.reject(error); // propagate the error without
+        // appending stack traces
+    });
+};
+export { is, } from './index';