@rwillians/qx 0.1.20 → 0.2.0

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

@@ -0,0 +1,189 @@
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    export interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    export interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    export interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    export interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    export interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    export interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+    export {};
+}
+/**
+ * @public  The Standard Schema interface.
+ * @since   0.1.0
+ * @version 1
+ */
+export { type StandardSchemaV1 as Schema };
+/**
+ * @public  Infers the input type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type input<T extends StandardSchemaV1> = StandardSchemaV1.InferInput<T>;
+/**
+ * @public  Infers the Input type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type output<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+/**
+ * @public  Use any standard schema to parse a value.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const parse: <T extends StandardSchemaV1>(schema: T, value: unknown) => StandardSchemaV1.Result<output<T>>;
+/**
+ * @public  Defines an array of a given standard schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxArray<T extends StandardSchemaV1> = 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 StandardSchemaV1>(schema: T) => QxArray<T>;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export type QxBoolean = 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 = 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> = 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 = 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 StandardSchemaV1 = StandardSchemaV1> = 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 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 = 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, StandardSchemaV1>> = 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, 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 = 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/types/utils.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @private Converts a snake_case string to camelCase at the type
+ *          level.
+ * @since   0.1.17
+ * @version 1
+ */
+type CamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelCase<U>>}` : S;
+/**
+ * @private Converts a camelCase string to snake_case at the type
+ *          level.
+ * @since   0.1.17
+ * @version 1
+ */
+type SnakeCase<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Lowercase<T>}${SnakeCase<U>}` : `${Lowercase<T>}_${SnakeCase<Uncapitalize<U>>}` : S;
+/**
+ * @private Converts a snake_case string to camelCase.
+ * @since   0.1.0
+ * @version 2
+ */
+export declare const camelCase: <T extends string>(str: T) => CamelCase<T>;
+/**
+ * @private Same as {@link Object.prototype.entries} but with better
+ *          types.
+ * @since   0.1.17
+ * @version 1
+ */
+export declare const entries: <T extends Record<string, any>>(obj: T) => [keyof T, T[keyof T]][];
+/**
+   * @private Simplified check for plain objects.
+   * @since   0.1.0
+   * @version 1
+   */
+export declare const isPlainObject: (value: unknown) => value is Record<string, any>;
+/**
+ * @private Same as {@link Object.prototype.keys} but with better
+ *          types.
+ * @since   0.1.17
+ * @version 1
+ */
+export declare const keys: <T extends Record<string, any>>(obj: T) => (keyof T)[];
+/**
+   * @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: <T extends string>(str: T) => SnakeCase<T>;
+/**
+   * @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[];
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/qx",
   "description": "A zero-dependencies teeny tiny ORM for SQLite.",
-  "version": "0.1.20",
+  "version": "0.2.0",
   "author": "Rafael Willians <me@rwillians.com>",
   "license": "MIT",
   "repository": {
@@ -62,9 +62,10 @@
     "build:esm": "bun run --bun tsc --project tsconfig-esm.json"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.3.0"
   },
   "peerDependencies": {
-    "typescript": "latest"
+    "typescript": "^5.9.3"
   }
 }