@rwillians/exto 0.1.0 → 0.1.2

package/dist/types/index.d.ts

@@ -0,0 +1,315 @@
+import * as std from './standard-schema';
+import { ValidationError } from './standard-schema';
+import { type CamelCase, type Expand } from './utils';
+type Primitive = 'BIGINT' | 'BINARY' | 'BOOLEAN' | 'CITEXT' | 'DATE' | 'DATETIME' | 'DECIMAL' | 'FLOAT' | 'INTEGER' | 'JSON' | 'SEQUENCE' | 'STRING' | 'TEXT' | 'UUID';
+type ColumnProps<S extends std.Schema = std.Schema> = {
+    type: Primitive;
+    schema: S;
+    default?: unknown;
+    generated?: true;
+    length?: number;
+    precision?: number;
+    scale?: number;
+    nullable?: true;
+    primaryKey?: true;
+    unique?: true;
+};
+type Column<K extends string = string, P extends ColumnProps = ColumnProps> = P & {
+    key: K;
+    name: string;
+    input: std.input<P['schema']>;
+    output: std.output<P['schema']>;
+};
+declare class ColumnBuilder<P extends ColumnProps> {
+    readonly props: P;
+    constructor(props: P);
+    default(value: std.output<P['schema']> | (() => std.output<P['schema']>)): ColumnBuilder<Expand<P & {
+        default: typeof value;
+    }>>;
+    generated(): ColumnBuilder<Expand<P & {
+        generated: true;
+    }>>;
+    nullable(): ColumnBuilder<Expand<Omit<P, "schema"> & {
+        nullable: true;
+        schema: std.Schema<std.input<P['schema']> | null, std.output<P['schema']> | null>;
+    }>>;
+    primaryKey(): ColumnBuilder<Expand<P & {
+        primaryKey: true;
+    }>>;
+    unique(): ColumnBuilder<Expand<P & {
+        unique: true;
+    }>>;
+}
+declare const column: <P extends ColumnProps>(props: P) => ColumnBuilder<P>;
+declare const types: {
+    bigint: () => ColumnBuilder<{
+        type: "BIGINT";
+        schema: std.Schema<bigint, bigint>;
+    }>;
+    binary: () => ColumnBuilder<{
+        type: "BINARY";
+        schema: std.Schema<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    }>;
+    boolean: () => ColumnBuilder<{
+        type: "BOOLEAN";
+        schema: std.Schema<boolean, boolean>;
+    }>;
+    citext: () => ColumnBuilder<{
+        type: "CITEXT";
+        schema: std.Schema<string, string>;
+    }>;
+    date: () => ColumnBuilder<{
+        type: "DATE";
+        schema: std.Schema<string, string>;
+    }>;
+    datetime: () => ColumnBuilder<{
+        type: "DATETIME";
+        schema: std.Schema<string | number | Date, Date>;
+    }>;
+    decimal: (options?: {
+        precision: number;
+        scale: number;
+    }) => ColumnBuilder<{
+        precision?: number | undefined;
+        scale?: number | undefined;
+        type: "DECIMAL";
+        schema: std.Schema<number, number>;
+    }>;
+    enum: <const T extends readonly [string, ...string[]]>(values: T) => ColumnBuilder<{
+        type: "STRING";
+        schema: std.Schema<T[number], T[number]>;
+        length: number;
+    }>;
+    float: () => ColumnBuilder<{
+        type: "FLOAT";
+        schema: std.Schema<number, number>;
+    }>;
+    integer: () => ColumnBuilder<{
+        type: "INTEGER";
+        schema: std.Schema<number, number>;
+    }>;
+    json: <S extends std.Schema>(schema: S) => ColumnBuilder<{
+        type: "JSON";
+        schema: S;
+    }>;
+    sequence: () => ColumnBuilder<{
+        type: "SEQUENCE";
+        schema: std.Schema<number, number>;
+        generated: true;
+    }>;
+    string: ({ size }?: {
+        size?: number;
+    }) => ColumnBuilder<{
+        type: "STRING";
+        schema: std.Schema<string, string>;
+        length: number;
+    }>;
+    text: () => ColumnBuilder<{
+        type: "TEXT";
+        schema: std.Schema<string, string>;
+    }>;
+    uuid: () => ColumnBuilder<{
+        type: "UUID";
+        schema: std.Schema<string, string>;
+    }>;
+};
+type Columns = Record<string, Column>;
+type Table<N extends string = string, C extends Columns = Columns> = {
+    name: N;
+    alias: string;
+    columns: C;
+};
+type OmitOnInsert = {
+    generated: true;
+};
+type OptionalOnInsert = {
+    default: unknown;
+} | {
+    nullable: true;
+};
+type OmitOnUpdate = {
+    generated: true;
+} | {
+    primaryKey: true;
+};
+type NumericType = 'BIGINT' | 'DECIMAL' | 'FLOAT' | 'INTEGER';
+type Infer<C extends Columns> = Expand<{
+    [K in keyof C]: C[K]['output'];
+}>;
+type InferForInsert<C extends Columns> = Expand<{
+    [K in keyof C as C[K] extends OmitOnInsert | OptionalOnInsert ? never : K]: C[K]['input'];
+} & {
+    [K in keyof C as C[K] extends OmitOnInsert ? never : C[K] extends OptionalOnInsert ? K : never]?: C[K]['input'];
+}>;
+type InferForUpdate<C extends Columns> = Expand<{
+    [K in keyof C as C[K] extends OmitOnUpdate ? never : K]?: C[K]['input'];
+}>;
+type NumericKeys<C extends Columns> = {
+    [K in keyof C]: C[K] extends OmitOnUpdate ? never : C[K]['type'] extends NumericType ? K : never;
+}[keyof C];
+type DefinedTable<N extends string, C extends Columns> = Table<N, C> & {
+    as: (alias: string) => DefinedTable<N, C>;
+    infer: Infer<C>;
+    inferForInsert: InferForInsert<C>;
+    inferForUpdate: InferForUpdate<C>;
+};
+declare const defineTable: <N extends string, S extends Record<string, ColumnBuilder<ColumnProps>>>(name: N, shapeFn: (t: typeof types) => S) => DefinedTable<N, { [K in keyof S & string as CamelCase<K>]: Column<CamelCase<K>, S[K]['props']>; }>;
+type Codec = {
+    encode: (value: any) => unknown;
+    decode: (value: any) => unknown;
+};
+/**
+ * Everything that differs between database engines. SQL generation, param
+ * collection, validation and encoding/decoding all live in the core.
+ *
+ * `generated` returns the DDL that makes the database generate the column's
+ * value, or `undefined` when the database can't natively, in which case the
+ * value is generated client-side on insert.
+ */
+type DialectName = 'postgres' | 'sqlite' | (string & {});
+interface Dialect {
+    name: DialectName;
+    placeholder(index: number): string;
+    type(column: Column): string;
+    generated(column: Column): string | undefined;
+    codecs: Record<Primitive, Codec>;
+}
+interface ILogger {
+    debug(sql: string, params: unknown[]): void;
+    error(sql: string, params: unknown[], error: unknown): void;
+}
+type Row = Record<string, unknown>;
+interface IDatabase {
+    readonly dialect: Dialect;
+    readonly loggers: ILogger[];
+    execute(sql: string, params: unknown[]): Promise<Row[]>;
+    transaction<T>(fn: (tx: IDatabase) => Promise<T>): Promise<T>;
+}
+declare const exec: (db: IDatabase, sql: string, params?: unknown[]) => Promise<void>;
+type Op = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'like' | 'not like' | 'in' | 'not in' | 'is' | 'is not';
+type ValueFor<V, O extends Op> = O extends 'is' | 'is not' ? null : O extends 'in' | 'not in' ? NonNullable<V>[] : O extends 'like' | 'not like' ? string : NonNullable<V>;
+type ExprNode = {
+    key: string;
+    op: Op;
+    value: unknown;
+} | {
+    group: 'AND' | 'OR';
+    exprs: ExprNode[];
+};
+declare const COLUMNS: unique symbol;
+type Expr<C extends Columns> = ExprNode & {
+    readonly [COLUMNS]?: (columns: C) => C;
+};
+declare const expr: (<C extends Columns, K extends keyof C & string, O extends Op>(key: K, op: O, value: ValueFor<C[K]['output'], O>) => Expr<C>) & {
+    and: <C extends Columns>(exprs: Expr<C>[]) => Expr<C>;
+    or: <C extends Columns>(exprs: Expr<C>[]) => Expr<C>;
+};
+type Condition = {
+    col: Column;
+    op: Op;
+    value: unknown;
+} | {
+    group: 'AND' | 'OR';
+    conditions: Condition[];
+};
+type Changes<C extends Columns> = {
+    set?: InferForUpdate<C>;
+    inc?: {
+        [K in NumericKeys<C>]?: number;
+    };
+};
+type Conflict<C extends Columns> = {
+    on: (keyof C & string)[];
+    do: 'nothing' | 'throw' | (Changes<C> & {
+        replace?: (keyof InferForUpdate<C> & string)[];
+    });
+};
+type InsertOptions<C extends Columns> = {
+    conflict?: Conflict<C>;
+};
+declare class InsertBuilder<T extends Table> {
+    private readonly table;
+    private readonly rows;
+    constructor(table: T, rows?: InferForInsert<T['columns']>[]);
+    values(rows: InferForInsert<T['columns']> | InferForInsert<T['columns']>[]): InsertBuilder<T>;
+    insert(db: IDatabase, options?: InsertOptions<T['columns']> & {
+        returning?: true;
+    }): Promise<Infer<T['columns']>[]>;
+    insert(db: IDatabase, options: InsertOptions<T['columns']> & {
+        returning: false;
+    }): Promise<undefined>;
+    insert<K extends keyof T['columns'] & string>(db: IDatabase, options: InsertOptions<T['columns']> & {
+        returning: K[];
+    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
+    private renderConflict;
+}
+declare const into: <T extends Table>(table: T) => InsertBuilder<T>;
+type Direction = 'ASC' | 'DESC';
+type Query<T extends Table> = {
+    table: T;
+    select?: string[];
+    where: Condition[];
+    orderBy: [Column, Direction][];
+    limit?: number;
+    offset?: number;
+};
+type Keys<T extends Table> = keyof T['columns'] & string;
+declare class QueryBuilder<T extends Table, S extends Keys<T> = Keys<T>> {
+    private readonly query;
+    constructor(query: Query<T>);
+    select<K extends Keys<T>>(keys: K[]): QueryBuilder<T, K>;
+    where<K extends Keys<T>, O extends Op>(key: K, op: O, value: ValueFor<T['columns'][K]['output'], O>): QueryBuilder<T, S>;
+    where(expr: Expr<T['columns']>): QueryBuilder<T, S>;
+    orderBy(keys: (Keys<T> | [Keys<T>, Direction])[]): QueryBuilder<T, S>;
+    limit(n: number): QueryBuilder<T, S>;
+    offset(n: number): QueryBuilder<T, S>;
+    all(db: IDatabase): Promise<Expand<Pick<Expand<T["columns"] extends infer T_1 extends Columns ? { [K in keyof T_1]: T_1[K]["output"]; } : never>, S>>[]>;
+    one(db: IDatabase): Promise<Expand<Pick<Expand<T["columns"] extends infer T_1 extends Columns ? { [K in keyof T_1]: T_1[K]["output"]; } : never>, S>>>;
+    exists(db: IDatabase): Promise<boolean>;
+    count(db: IDatabase): Promise<number>;
+    update(db: IDatabase, changes: Changes<T['columns']> & {
+        returning: false;
+    }): Promise<undefined>;
+    update<K extends keyof T['columns'] & string>(db: IDatabase, changes: Changes<T['columns']> & {
+        returning: K[];
+    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
+    update(db: IDatabase, changes: Changes<T['columns']> & {
+        returning?: true;
+    }): Promise<Infer<T['columns']>[]>;
+    delete(db: IDatabase, options: {
+        returning: true;
+    }): Promise<Infer<T['columns']>[]>;
+    delete<K extends keyof T['columns'] & string>(db: IDatabase, options: {
+        returning: K[];
+    }): Promise<Expand<Pick<Infer<T['columns']>, K>>[]>;
+    delete(db: IDatabase, options?: {
+        returning?: false;
+    }): Promise<undefined>;
+    private renderSelect;
+    private top;
+    private assertUnbounded;
+}
+declare const from: <T extends Table>(table: T) => QueryBuilder<T, Keys<T>>;
+type IndexOptions = {
+    ifNotExists?: boolean;
+    name?: string;
+};
+declare const createIndex: <T extends Table>(table: T, keys: (keyof T['columns'] & string)[], { ifNotExists, name, unique, }?: IndexOptions & {
+    unique?: boolean;
+}) => {
+    onto: (db: IDatabase) => Promise<void>;
+};
+declare const create: {
+    table: (table: Table, { ifNotExists }?: {
+        ifNotExists?: boolean;
+    }) => {
+        onto: (db: IDatabase) => Promise<void>;
+    };
+    index: typeof createIndex;
+    uniqueIndex: <T extends Table>(table: T, keys: (keyof T['columns'] & string)[], options?: IndexOptions) => {
+        onto: (db: IDatabase) => Promise<void>;
+    };
+};
+type Migration = (db: IDatabase) => Promise<void>;
+declare const defineMigrations: (migrations: Record<string, Migration>) => (db: IDatabase) => Promise<void>;
+export { type Codec, type Column, type ColumnProps, type Dialect, type DialectName, type Expr, type IDatabase, type ILogger, type Migration, type Primitive, type Row, type Table, ValidationError, column, create, defineMigrations, defineTable as table, exec, expr, from, into, types as t, };

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

@@ -0,0 +1,174 @@
+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 output type of a Standard Schema.
+ * @since   0.1.0
+ * @version 1
+ */
+export type output<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+/**
+ * @public  Thrown when a value fails validation, carrying every issue found.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare class ValidationError extends Error {
+    readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+    constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+/**
+ * @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  Like {@link parse}, but returns the value or throws a
+ *          {@link ValidationError}.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const parseOrThrow: <T extends StandardSchemaV1>(schema: T, value: unknown) => 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) => StandardSchemaV1<input<T>[], output<T>[]>;
+/**
+ * @public  Defines a standard schema for bigints.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const bigint: () => StandardSchemaV1<bigint, bigint>;
+/**
+ * @public  Defines a standard schema for boolean values.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const boolean: () => StandardSchemaV1<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
+ */
+export declare const date: () => StandardSchemaV1<string | number | Date, Date>;
+/**
+ * @public  Defines a standard schema for one of the given string values.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const enumOf: <const T extends readonly string[]>(values: T) => StandardSchemaV1<T[number], T[number]>;
+/**
+ * @public  Defines a standard schema for instances of a given class.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const instanceOf: <T>(ctor: new (...args: any[]) => T) => StandardSchemaV1<T, T>;
+/**
+ * @public  Defines a standard schema for integers, within the safe integer
+ *          range by default.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const integer: ({ min, max }?: {
+    max?: number | undefined;
+    min?: number | undefined;
+}) => StandardSchemaV1<number, number>;
+/**
+ * @public  Defines a standard schema for calendar dates as `YYYY-MM-DD`
+ *          strings.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const isoDate: () => StandardSchemaV1<string, string>;
+/**
+ * @public  Makes a given standard schema accept `null`.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const nullable: <T extends StandardSchemaV1>(schema: T) => StandardSchemaV1<input<T> | null, output<T> | null>;
+/**
+ * @public  Defines a standard schema for finite numbers.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const number: () => StandardSchemaV1<number, number>;
+/**
+ * @public  Makes a given standard schema accept `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const optional: <T extends StandardSchemaV1>(schema: T) => StandardSchemaV1<input<T> | undefined, output<T> | undefined>;
+/**
+ * @public  Defines a standard schema for strings, optionally limited in
+ *          length.
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const string: ({ max }?: {
+    max?: number;
+}) => StandardSchemaV1<string, string>;
+/**
+ * @public  Defines a standard schema for objects of a given shape. Keys
+ *          missing from the shape are rejected, keys missing from the input
+ *          are validated as `undefined`.
+ * @since   0.1.0
+ * @version 1
+ */
+type Expand<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : never;
+type OptionalKeys<T extends Record<string, StandardSchemaV1>> = {
+    [K in keyof T]: undefined extends input<T[K]> ? K : never;
+}[keyof T];
+export declare const strictObject: <T extends Record<string, StandardSchemaV1>>(shape: T) => StandardSchemaV1<Expand<{ [K in Exclude<keyof T, OptionalKeys<T>>]: input<T[K]>; } & { [K in OptionalKeys<T>]?: input<T[K]> | undefined; }>, Expand<{ [K in Exclude<keyof T, OptionalKeys<T>>]: output<T[K]>; } & { [K in OptionalKeys<T>]?: output<T[K]> | undefined; }>>;
+/**
+ * @public  Defines a standard schema for UUID strings (any version).
+ * @since   0.1.0
+ * @version 1
+ */
+export declare const uuid: () => StandardSchemaV1<string, string>;

package/dist/types/utils.d.ts

@@ -0,0 +1,11 @@
+type Ctor<T> = new (...args: any[]) => T;
+export type Expand<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : never;
+export type CamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<CamelCase<U>>}` : S;
+export declare const camelCase: <T extends string>(str: T) => CamelCase<T>;
+export declare const snakeCase: (str: string) => string;
+export declare const wrap: <T>(value: T | T[]) => T[];
+export declare function raise(message: string, cause?: Error): never;
+export declare function raise(ctor: Ctor<Error>, message: string, cause?: Error): never;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rwillians/exto",
   "description": "A zero-dependencies teeny tiny ORM for SQL databases.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "author": "Rafael Willians <me@rwillians.com>",
   "license": "MIT",
   "publishConfig": {
@@ -12,17 +12,17 @@
     "url": "git://github.com/rwillians/exto.git"
   },
   "keywords": [
-    "query",
     "builder",
-    "query builder",
+    "bun",
+    "orm",
     "postgres",
+    "query builder",
+    "query",
     "sql",
     "sqlite",
-    "typescript",
     "type-safe",
     "type-safety",
-    "orm",
-    "bun"
+    "typescript"
   ],
   "type": "module",
   "module": "dist/esm/index.js",

package/dist/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore