rado 0.1.23 → 0.1.25

package/dist/lib/Param.d.ts

@@ -1,15 +1,20 @@
-export declare enum ParamType {
-    Value = "Value",
-    Named = "Named"
-}
-export type ParamData = {
-    type: ParamType.Value;
-    value: any;
-} | {
-    type: ParamType.Named;
-    name: string;
-};
-export declare const ParamData: {
-    Value(value: any): ParamData;
-    Named(name: string): ParamData;
-};
+import { Expr } from './Expr';
+export declare enum ParamType {
+    Value = "Value",
+    Named = "Named"
+}
+export type ParamData = {
+    type: ParamType.Value;
+    value: any;
+} | {
+    type: ParamType.Named;
+    name: string;
+};
+export declare const ParamData: {
+    Value(value: any): ParamData;
+    Named(name: string): ParamData;
+};
+export type Params<T> = {
+    [K in keyof T]: Expr<T[K]>;
+};
+export declare function createParams<T>(): Params<T>;

package/dist/lib/Param.js

@@ -1,4 +1,5 @@
 // src/lib/Param.ts
+import { Expr, ExprData } from "./Expr.js";
 var ParamType = /* @__PURE__ */ ((ParamType2) => {
   ParamType2["Value"] = "Value";
   ParamType2["Named"] = "Named";
@@ -12,7 +13,15 @@ var ParamData = {
     return { type: "Named" /* Named */, name };
   }
 };
+function createParams() {
+  return new Proxy({}, {
+    get(target, prop) {
+      return new Expr(ExprData.Param(ParamData.Named(prop)));
+    }
+  });
+}
 export {
   ParamData,
-  ParamType
+  ParamType,
+  createParams
 };

package/dist/lib/Query.d.ts

@@ -1,108 +1,108 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { IndexData } from './Index';
-import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
-        limit?: number;
-        offset?: number;
-        type: QueryType;
-        where?: ExprData;
-        orderBy?: Array<OrderBy>;
-        groupBy?: Array<ExprData>;
-        having?: ExprData;
-        selection?: ExprData;
-        singleResult?: boolean;
-    }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
-        type: QueryType.Select;
-        selection: ExprData;
-        from: Target;
-    }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
-        type: QueryType.Update;
-        table: Schema;
-        set?: Record<string, any>;
-    }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
-        type: QueryType.Delete;
-        table: Schema;
-    }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
-        type: QueryType.CreateTable;
-        table: Schema;
-        ifNotExists?: boolean;
-    }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: IndexData;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
-        type: QueryType.Batch;
-        queries: Array<Query<any>>;
-    }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
-        Begin = "Begin",
-        Commit = "Commit",
-        Rollback = "Rollback"
-    }
-    interface Transaction extends QueryBase {
-        type: QueryType.Transaction;
-        id: string;
-        op: TransactionOperation;
-    }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
-        type: QueryType.Raw;
-        expectedReturn?: 'row' | 'rows';
-        strings: ReadonlyArray<string>;
-        params: Array<any>;
-    }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
-    interface AlterTable extends QueryBase {
-        type: QueryType.AlterTable;
-        table: Schema;
-        alterColumn?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { IndexData } from './Index';
+import { OrderBy } from './OrderBy';
+import { Schema } from './Schema';
+import { Target } from './Target';
+export declare enum QueryType {
+    Insert = "Insert",
+    Select = "Select",
+    Update = "Update",
+    Delete = "Delete",
+    CreateTable = "CreateTable",
+    CreateIndex = "CreateIndex",
+    DropIndex = "DropIndex",
+    AlterTable = "AlterTable",
+    Batch = "Batch",
+    Transaction = "Transaction",
+    Raw = "Raw"
+}
+export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
+export declare namespace Query {
+    interface QueryBase {
+        limit?: number;
+        offset?: number;
+        type: QueryType;
+        where?: ExprData;
+        orderBy?: Array<OrderBy>;
+        groupBy?: Array<ExprData>;
+        having?: ExprData;
+        selection?: ExprData;
+        singleResult?: boolean;
+    }
+    interface Insert extends QueryBase {
+        type: QueryType.Insert;
+        into: Schema;
+        data: Array<any>;
+    }
+    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
+    interface Select extends QueryBase {
+        type: QueryType.Select;
+        selection: ExprData;
+        from: Target;
+    }
+    function Select(select: Omit<Select, 'type'>): Query.Select;
+    interface Update extends QueryBase {
+        type: QueryType.Update;
+        table: Schema;
+        set?: Record<string, any>;
+    }
+    function Update(update: Omit<Update, 'type'>): Query.Update;
+    interface Delete extends QueryBase {
+        type: QueryType.Delete;
+        table: Schema;
+    }
+    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
+    interface CreateTable extends QueryBase {
+        type: QueryType.CreateTable;
+        table: Schema;
+        ifNotExists?: boolean;
+    }
+    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
+    interface CreateIndex extends QueryBase {
+        type: QueryType.CreateIndex;
+        table: Schema;
+        index: IndexData;
+        ifNotExists?: boolean;
+    }
+    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
+    interface DropIndex extends QueryBase {
+        type: QueryType.DropIndex;
+        table: Schema;
+        name: string;
+        ifExists?: boolean;
+    }
+    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
+    interface Batch extends QueryBase {
+        type: QueryType.Batch;
+        queries: Array<Query<any>>;
+    }
+    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
+    enum TransactionOperation {
+        Begin = "Begin",
+        Commit = "Commit",
+        Rollback = "Rollback"
+    }
+    interface Transaction extends QueryBase {
+        type: QueryType.Transaction;
+        id: string;
+        op: TransactionOperation;
+    }
+    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
+    type RawReturn = 'row' | 'rows' | undefined;
+    interface Raw extends QueryBase {
+        type: QueryType.Raw;
+        expectedReturn?: 'row' | 'rows';
+        strings: ReadonlyArray<string>;
+        params: Array<any>;
+    }
+    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
+    interface AlterTable extends QueryBase {
+        type: QueryType.AlterTable;
+        table: Schema;
+        alterColumn?: ColumnData;
+        addColumn?: ColumnData;
+        dropColumn?: string;
+    }
+    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
+}

package/dist/lib/Sanitizer.d.ts

@@ -1,4 +1,4 @@
-export interface Sanitizer {
-    escapeValue(value: any): string;
-    escapeIdentifier(ident: string): string;
-}
+export interface Sanitizer {
+    escapeValue(value: any): string;
+    escapeIdentifier(ident: string): string;
+}

package/dist/lib/Schema.d.ts

@@ -1,18 +1,18 @@
-import { ColumnData } from './Column';
-import { Formatter } from './Formatter';
-import { IndexData } from './Index';
-import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}
+import { ColumnData } from './Column';
+import { Formatter } from './Formatter';
+import { IndexData } from './Index';
+import { Query } from './Query';
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, IndexData>;
+}
+export interface SchemaInstructions {
+    columns: Record<string, string>;
+    indexes: Record<string, string>;
+}
+export declare namespace Schema {
+    function create(schema: Schema): Query.Batch;
+    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
+}

package/dist/lib/Schema.js

@@ -27,7 +27,7 @@ var Schema;
       } else if (!schemaCol) {
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
-        const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        const { sql: instruction } = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
@@ -43,13 +43,13 @@ var Schema;
       if (!localInstruction) {
         res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
       } else if (!schemaIndex) {
-        res.push(Query.DropIndex({ table: schema, name: indexName }));
+        res.unshift(Query.DropIndex({ table: schema, name: indexName }));
       } else {
-        const [instruction] = formatter.formatCreateIndex(
+        const { sql: instruction } = formatter.formatCreateIndex(
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
-          res.push(Query.DropIndex({ table: schema, name: indexName }));
+          res.unshift(Query.DropIndex({ table: schema, name: indexName }));
           res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
         }
       }

package/dist/lib/Selection.d.ts

@@ -1,20 +1,20 @@
-import type { Cursor } from './Cursor';
-import type { Expr } from './Expr';
-type SelectionBase = Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
-interface SelectionRecord extends Record<string, Selection> {
-}
-export type Selection = SelectionBase | SelectionRecord;
-export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
-    type Infer<T> = T extends {
-        [__tableType](): infer K;
-    } ? K : T extends {
-        [__cursorType](): infer K;
-    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T]: Infer<T[K]>;
-    } : T;
-    type With<A, B> = Expr<Combine<A, B>>;
-    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
-}
-export {};
+import type { Cursor } from './Cursor';
+import type { Expr } from './Expr';
+type SelectionBase = Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
+interface SelectionRecord extends Record<string, Selection> {
+}
+export type Selection = SelectionBase | SelectionRecord;
+export declare namespace Selection {
+    const __tableType: unique symbol;
+    const __cursorType: unique symbol;
+    type Infer<T> = T extends {
+        [__tableType](): infer K;
+    } ? K : T extends {
+        [__cursorType](): infer K;
+    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
+        [K in keyof T]: Infer<T[K]>;
+    } : T;
+    type With<A, B> = Expr<Combine<A, B>>;
+    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
+}
+export {};

package/dist/lib/Statement.d.ts

@@ -1,61 +1,71 @@
-import { Sanitizer } from './Sanitizer';
-declare enum TokenType {
-    Raw = "Raw",
-    Identifier = "Identifier",
-    Value = "Value",
-    Indent = "Indent",
-    Dedent = "Dedent"
-}
-declare class Token {
-    type: TokenType;
-    data: any;
-    constructor(type: TokenType, data: any);
-    static Raw(data: string): Token;
-    static Indent(): Token;
-    static Dedent(): Token;
-    static Identifier(data: string): Token;
-    static Value(data: any): Token;
-}
-export interface CompileOptions {
-    formatInline?: boolean;
-    spaces?: number;
-}
-export declare class Statement {
-    tokens: Array<Token>;
-    constructor(tokens: Array<Token>);
-    concat(...tokens: Array<Token | Statement>): Statement;
-    static create(from: string | Statement): Statement;
-    static tag(strings: ReadonlyArray<string>, ...params: Array<any>): Statement;
-    space(): Statement;
-    call(method: string, ...args: Array<Statement>): Statement;
-    addCall(method: string, ...args: Array<Statement>): Statement;
-    add(addition: undefined | string | Statement): Statement;
-    addLine(addition: undefined | string | Statement): Statement;
-    addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
-    indent(): Statement;
-    dedent(): Statement;
-    newline(ignore?: boolean): Statement;
-    identifier(name: string): Statement;
-    addIdentifier(name: string): Statement;
-    value(value: any): Statement;
-    addValue(value: any): Statement;
-    raw(query: string): Statement;
-    parenthesis(inner: string | Statement): Statement;
-    addParenthesis(stmnt: string | Statement): Statement;
-    separated(input: Array<Statement>, separator?: string): Statement;
-    addSeparated(input: Array<Statement>, separator?: string): Statement;
-    isEmpty(): boolean;
-    compile(sanitizer: Sanitizer, formatInline?: boolean): Statement.Compiled;
-}
-export declare namespace Statement {
-    type Compiled = [sql: string, params: Array<any>];
-}
-export declare function newline(): Statement;
-export declare function raw(raw: string): Statement;
-export declare function identifier(name: string): Statement;
-export declare function value(value: any): Statement;
-export declare function empty(): Statement;
-export declare function parenthesis(stmnt: Statement): Statement;
-export declare function call(method: string, ...args: Array<Statement>): Statement;
-export declare function separated(input: Array<Statement>, separator?: string): Statement;
-export {};
+import { ParamData } from './Param';
+import { Sanitizer } from './Sanitizer';
+declare enum TokenType {
+    Raw = "Raw",
+    Identifier = "Identifier",
+    Value = "Value",
+    Param = "Param",
+    Indent = "Indent",
+    Dedent = "Dedent"
+}
+declare class Token {
+    type: TokenType;
+    data: any;
+    constructor(type: TokenType, data: any);
+    static Raw(data: string): Token;
+    static Indent(): Token;
+    static Dedent(): Token;
+    static Identifier(data: string): Token;
+    static Value(data: any): Token;
+    static Param(name: string): Token;
+}
+export interface CompileOptions {
+    formatInline?: boolean;
+    spaces?: number;
+}
+export declare class Statement {
+    tokens: Array<Token>;
+    constructor(tokens: Array<Token>);
+    concat(...tokens: Array<Token | Statement>): Statement;
+    static create(from: string | Statement): Statement;
+    static tag(strings: ReadonlyArray<string>, params: Array<Statement>): Statement;
+    space(): Statement;
+    call(method: string, ...args: Array<Statement>): Statement;
+    addCall(method: string, ...args: Array<Statement>): Statement;
+    add(addition: undefined | string | Statement): Statement;
+    addLine(addition: undefined | string | Statement): Statement;
+    addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
+    indent(): Statement;
+    dedent(): Statement;
+    newline(ignore?: boolean): Statement;
+    identifier(name: string): Statement;
+    addIdentifier(name: string): Statement;
+    value(value: any): Statement;
+    addValue(value: any): Statement;
+    param(name: string): Statement;
+    addParam(name: string): Statement;
+    raw(query: string): Statement;
+    parenthesis(inner: string | Statement): Statement;
+    addParenthesis(stmnt: string | Statement): Statement;
+    separated(input: Array<Statement>, separator?: string): Statement;
+    addSeparated(input: Array<Statement>, separator?: string): Statement;
+    isEmpty(): boolean;
+    compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
+}
+export declare class CompiledStatement {
+    sql: string;
+    private paramData;
+    constructor(sql: string, paramData: Array<ParamData>);
+    params(input?: Record<string, any>): Array<any>;
+    toString(): string;
+}
+export declare function newline(): Statement;
+export declare function raw(raw: string): Statement;
+export declare function identifier(name: string): Statement;
+export declare function value(value: any): Statement;
+export declare function param(name: string): Statement;
+export declare function empty(): Statement;
+export declare function parenthesis(stmnt: Statement): Statement;
+export declare function call(method: string, ...args: Array<Statement>): Statement;
+export declare function separated(input: Array<Statement>, separator?: string): Statement;
+export {};

package/dist/lib/Statement.js

@@ -1,4 +1,5 @@
 // src/lib/Statement.ts
+import { ParamData, ParamType } from "./Param.js";
 var Token = class {
   constructor(type, data) {
     this.type = type;
@@ -19,6 +20,9 @@ var Token = class {
   static Value(data) {
     return new Token("Value" /* Value */, data);
   }
+  static Param(name) {
+    return new Token("Param" /* Param */, name);
+  }
 };
 var SEPARATE = ",";
 var WHITESPACE = " ";
@@ -37,9 +41,12 @@ var Statement = class {
   static create(from) {
     return typeof from === "string" ? raw(from) : from;
   }
-  static tag(strings, ...params) {
+  static tag(strings, params) {
     return new Statement(
-      strings.flatMap((s, i) => [Token.Raw(s), Token.Value(params[i])]).slice(0, -1)
+      strings.flatMap((s, i) => {
+        const param2 = params[i];
+        return [Token.Raw(s)].concat(param2 ? param2.tokens : []);
+      })
     );
   }
   space() {
@@ -93,6 +100,12 @@ var Statement = class {
   addValue(value2) {
     return this.space().value(value2);
   }
+  param(name) {
+    return this.concat(Token.Param(name));
+  }
+  addParam(name) {
+    return this.space().param(name);
+  }
   raw(query) {
     if (!query)
       return this;
@@ -118,7 +131,7 @@ var Statement = class {
     return this.tokens.length === 0 || this.tokens.length === 1 && this.tokens[0].type === "Raw" /* Raw */ && this.tokens[0].data === "";
   }
   compile(sanitizer, formatInline = false) {
-    let sql = "", params = [], indent = "";
+    let sql = "", paramData = [], indent = "";
     for (const token of this.tokens) {
       switch (token.type) {
         case "Raw" /* Raw */:
@@ -135,9 +148,13 @@ var Statement = class {
             sql += sanitizer.escapeValue(token.data);
           } else {
             sql += "?";
-            params.push(token.data === void 0 ? null : token.data);
+            paramData.push(ParamData.Value(token.data ?? null));
           }
           break;
+        case "Param" /* Param */:
+          sql += "?";
+          paramData.push(ParamData.Named(token.data));
+          break;
         case "Indent" /* Indent */:
           indent += "  ";
           break;
@@ -146,7 +163,26 @@ var Statement = class {
           break;
       }
     }
-    return [sql, params];
+    return new CompiledStatement(sql, paramData);
+  }
+};
+var CompiledStatement = class {
+  constructor(sql, paramData) {
+    this.sql = sql;
+    this.paramData = paramData;
+  }
+  params(input) {
+    return this.paramData.map((param2) => {
+      if (param2.type === ParamType.Named) {
+        if (input?.[param2.name] === void 0)
+          throw new TypeError(`Missing parameter ${param2.name}`);
+        return input[param2.name];
+      }
+      return param2.value;
+    });
+  }
+  toString() {
+    return this.sql;
   }
 };
 function newline() {
@@ -161,6 +197,9 @@ function identifier(name) {
 function value(value2) {
   return new Statement([Token.Value(value2)]);
 }
+function param(name) {
+  return new Statement([Token.Param(name)]);
+}
 function empty() {
   return new Statement([]);
 }
@@ -174,11 +213,13 @@ function separated(input, separator = SEPARATE) {
   return empty().separated(input, separator);
 }
 export {
+  CompiledStatement,
   Statement,
   call,
   empty,
   identifier,
   newline,
+  param,
   parenthesis,
   raw,
   separated,