rado 0.1.60 → 0.1.62

package/dist/Query.d.ts

@@ -0,0 +1,107 @@
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Index, 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: Index;
+        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/Query.js

@@ -0,0 +1,74 @@
+// src/Query.ts
+var QueryType = /* @__PURE__ */ ((QueryType2) => {
+  QueryType2["Insert"] = "Insert";
+  QueryType2["Select"] = "Select";
+  QueryType2["Update"] = "Update";
+  QueryType2["Delete"] = "Delete";
+  QueryType2["CreateTable"] = "CreateTable";
+  QueryType2["CreateIndex"] = "CreateIndex";
+  QueryType2["DropIndex"] = "DropIndex";
+  QueryType2["AlterTable"] = "AlterTable";
+  QueryType2["Batch"] = "Batch";
+  QueryType2["Transaction"] = "Transaction";
+  QueryType2["Raw"] = "Raw";
+  return QueryType2;
+})(QueryType || {});
+var Query;
+((Query2) => {
+  function Insert(insert) {
+    return { type: "Insert" /* Insert */, ...insert };
+  }
+  Query2.Insert = Insert;
+  function Select(select) {
+    return { type: "Select" /* Select */, ...select };
+  }
+  Query2.Select = Select;
+  function Update(update) {
+    return { type: "Update" /* Update */, ...update };
+  }
+  Query2.Update = Update;
+  function Delete(del) {
+    return { type: "Delete" /* Delete */, ...del };
+  }
+  Query2.Delete = Delete;
+  function CreateTable(create) {
+    return { type: "CreateTable" /* CreateTable */, ...create };
+  }
+  Query2.CreateTable = CreateTable;
+  function CreateIndex(create) {
+    return { type: "CreateIndex" /* CreateIndex */, ...create };
+  }
+  Query2.CreateIndex = CreateIndex;
+  function DropIndex(drop) {
+    return { type: "DropIndex" /* DropIndex */, ...drop };
+  }
+  Query2.DropIndex = DropIndex;
+  function Batch(batch) {
+    return { type: "Batch" /* Batch */, ...batch };
+  }
+  Query2.Batch = Batch;
+  let TransactionOperation;
+  ((TransactionOperation2) => {
+    TransactionOperation2["Begin"] = "Begin";
+    TransactionOperation2["Commit"] = "Commit";
+    TransactionOperation2["Rollback"] = "Rollback";
+  })(TransactionOperation = Query2.TransactionOperation || (Query2.TransactionOperation = {}));
+  function Transaction(transaction) {
+    return { type: "Transaction" /* Transaction */, ...transaction };
+  }
+  Query2.Transaction = Transaction;
+  function Raw(raw) {
+    if (raw.strings.some((chunk) => chunk.includes("?")))
+      throw new TypeError("SQL injection hazard");
+    return { type: "Raw" /* Raw */, ...raw };
+  }
+  Query2.Raw = Raw;
+  function AlterTable(alter) {
+    return { type: "AlterTable" /* AlterTable */, ...alter };
+  }
+  Query2.AlterTable = AlterTable;
+})(Query || (Query = {}));
+export {
+  Query,
+  QueryType
+};

package/dist/Sanitizer.d.ts

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

package/dist/Schema.d.ts

@@ -0,0 +1,23 @@
+import { ColumnData } from './Column';
+import { ExprData } from './Expr';
+import { Formatter } from './Formatter';
+import { Query } from './Query';
+export interface Index {
+    name: string;
+    on: Array<ExprData>;
+    where?: ExprData;
+}
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+    indexes: Record<string, Index>;
+}
+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/Schema.js

@@ -0,0 +1,60 @@
+// src/Schema.ts
+import { Query } from "./Query.js";
+var Schema;
+((Schema2) => {
+  function create(schema) {
+    const queries = [];
+    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
+    for (const index of Object.values(schema.indexes))
+      queries.push(Query.CreateIndex({ table: schema, index, ifNotExists: true }));
+    return Query.Batch({ queries });
+  }
+  Schema2.create = create;
+  function upgrade(formatter, local, schema) {
+    const columnNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.columns),
+      ...Object.keys(schema.columns)
+    ]);
+    const res = [];
+    for (const columnName of columnNames) {
+      const localInstruction = local.columns[columnName];
+      const schemaCol = schema.columns[columnName];
+      if (!localInstruction) {
+        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
+      } else if (!schemaCol) {
+        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
+      } else {
+        const [instruction] = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
+        }
+      }
+    }
+    const indexNames = /* @__PURE__ */ new Set([
+      ...Object.keys(local.indexes),
+      ...Object.keys(schema.indexes)
+    ]);
+    for (const indexName of indexNames) {
+      const localInstruction = local.indexes[indexName];
+      const schemaIndex = schema.indexes[indexName];
+      if (!localInstruction) {
+        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+      } else if (!schemaIndex) {
+        res.push(Query.DropIndex({ table: schema, name: indexName }));
+      } else {
+        const [instruction] = formatter.formatCreateIndex(
+          Query.CreateIndex({ table: schema, index: schemaIndex })
+        ).compile(formatter);
+        if (localInstruction !== instruction) {
+          res.push(Query.DropIndex({ table: schema, name: indexName }));
+          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
+        }
+      }
+    }
+    return res;
+  }
+  Schema2.upgrade = upgrade;
+})(Schema || (Schema = {}));
+export {
+  Schema
+};

package/dist/Selection.d.ts

@@ -0,0 +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 {};

package/dist/Selection.js

@@ -0,0 +1,7 @@
+// src/Selection.ts
+var Selection;
+((Selection2) => {
+})(Selection || (Selection = {}));
+export {
+  Selection
+};

package/dist/Statement.d.ts

@@ -0,0 +1,57 @@
+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 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(): 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 {};

package/dist/Statement.js

@@ -0,0 +1,184 @@
+// src/Statement.ts
+var Token = class {
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+  }
+  static Raw(data) {
+    return new Token("Raw" /* Raw */, data);
+  }
+  static Indent() {
+    return new Token("Indent" /* Indent */, null);
+  }
+  static Dedent() {
+    return new Token("Dedent" /* Dedent */, null);
+  }
+  static Identifier(data) {
+    return new Token("Identifier" /* Identifier */, data);
+  }
+  static Value(data) {
+    return new Token("Value" /* Value */, data);
+  }
+};
+var SEPARATE = ",";
+var WHITESPACE = " ";
+var NEWLINE = "\n";
+var Statement = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  concat(...tokens) {
+    return new Statement(
+      this.tokens.concat(
+        ...tokens.flatMap((t) => t instanceof Statement ? t.tokens : [t])
+      )
+    );
+  }
+  static create(from) {
+    return typeof from === "string" ? raw(from) : from;
+  }
+  static tag(strings, ...params) {
+    return new Statement(
+      strings.flatMap((s, i) => [Token.Raw(s), Token.Value(params[i])]).slice(0, -1)
+    );
+  }
+  space() {
+    return this.concat(Token.Raw(WHITESPACE));
+  }
+  call(method, ...args) {
+    return this.identifier(method).parenthesis(separated(args));
+  }
+  addCall(method, ...args) {
+    return this.space().call(method, ...args);
+  }
+  add(addition) {
+    if (!addition)
+      return this;
+    if (addition instanceof Statement && addition.isEmpty())
+      return this;
+    return this.space().concat(Statement.create(addition));
+  }
+  addLine(addition) {
+    if (!addition)
+      return this;
+    if (addition instanceof Statement && addition.isEmpty())
+      return this;
+    return this.newline().concat(Statement.create(addition));
+  }
+  addIf(condition, addition) {
+    if (!condition)
+      return this;
+    return this.add(typeof addition === "function" ? addition() : addition);
+  }
+  indent() {
+    return this.concat(Token.Indent());
+  }
+  dedent() {
+    return this.concat(Token.Dedent());
+  }
+  newline() {
+    return this.raw(NEWLINE);
+  }
+  identifier(name) {
+    return this.concat(Token.Identifier(name));
+  }
+  addIdentifier(name) {
+    return this.space().identifier(name);
+  }
+  value(value2) {
+    return this.concat(Token.Value(value2));
+  }
+  addValue(value2) {
+    return this.space().value(value2);
+  }
+  raw(query) {
+    if (!query)
+      return this;
+    return this.concat(Token.Raw(query));
+  }
+  parenthesis(inner) {
+    return this.raw("(").indent().newline().concat(Statement.create(inner)).dedent().newline().raw(")");
+  }
+  addParenthesis(stmnt) {
+    return this.space().parenthesis(stmnt);
+  }
+  separated(input, separator = SEPARATE) {
+    return this.concat(
+      ...input.flatMap(
+        (stmt, i) => i === 0 ? stmt.tokens : [Token.Raw(separator), Token.Raw(NEWLINE), ...stmt.tokens]
+      )
+    );
+  }
+  addSeparated(input, separator = SEPARATE) {
+    return this.space().separated(input, separator);
+  }
+  isEmpty() {
+    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 = "";
+    for (const token of this.tokens) {
+      switch (token.type) {
+        case "Raw" /* Raw */:
+          if (token.data === NEWLINE)
+            sql += NEWLINE + indent;
+          else
+            sql += token.data;
+          break;
+        case "Identifier" /* Identifier */:
+          sql += sanitizer.escapeIdentifier(token.data);
+          break;
+        case "Value" /* Value */:
+          if (formatInline) {
+            sql += sanitizer.escapeValue(token.data);
+          } else {
+            sql += "?";
+            params.push(token.data === void 0 ? null : token.data);
+          }
+          break;
+        case "Indent" /* Indent */:
+          indent += "  ";
+          break;
+        case "Dedent" /* Dedent */:
+          indent = indent.slice(0, -2);
+          break;
+      }
+    }
+    return [sql, params];
+  }
+};
+function newline() {
+  return new Statement([Token.Raw(NEWLINE)]);
+}
+function raw(raw2) {
+  return new Statement([Token.Raw(raw2)]);
+}
+function identifier(name) {
+  return new Statement([Token.Identifier(name)]);
+}
+function value(value2) {
+  return new Statement([Token.Value(value2)]);
+}
+function empty() {
+  return new Statement([]);
+}
+function parenthesis(stmnt) {
+  return empty().parenthesis(stmnt);
+}
+function call(method, ...args) {
+  return identifier(method).parenthesis(separated(args));
+}
+function separated(input, separator = SEPARATE) {
+  return empty().separated(input, separator);
+}
+export {
+  Statement,
+  call,
+  empty,
+  identifier,
+  newline,
+  parenthesis,
+  raw,
+  separated,
+  value
+};

package/dist/Table.d.ts

@@ -0,0 +1,56 @@
+import { Column } from './Column';
+import { Cursor } from './Cursor';
+import { Expr } from './Expr';
+import { Fields } from './Fields';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Update } from './Update';
+export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
+    [Selection.__tableType](): Table.Normalize<T>;
+    constructor(schema: Schema);
+    insertOne(record: Table.Insert<T>): Cursor.Batch<Table.Normalize<T>>;
+    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
+    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
+    createTable(): Cursor.Create;
+    as(alias: string): Table<T> & Fields<T>;
+    get(name: string): Expr<any>;
+    toExpr(): Expr<Table.Normalize<T>>;
+    schema(): Schema;
+}
+export declare namespace Table {
+    type Intersection<A, B> = A & B extends infer U ? {
+        [P in keyof U]: U[P];
+    } : never;
+    type OptionalKeys<T> = {
+        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.Primary<any, any> ? K : T[K] extends Column.Optional<any> ? K : never;
+    }[keyof T];
+    type RequiredKeys<T> = {
+        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Primary<any, any> ? never : T[K] extends Column.Optional<any> ? never : K;
+    }[keyof T];
+    type Optionals<T> = {
+        [K in keyof T]?: T[K] extends Column.Optional<infer V> ? V : T[K];
+    };
+    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
+    export type Normalize<T> = {
+        [K in keyof T]: T[K] extends Column.Optional<infer V> ? V : T[K] extends Column.Primary<infer K, infer V> ? string extends K ? V : V & {
+            [Column.isPrimary]: K;
+        } : T[K];
+    };
+    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
+    export {};
+}
+export interface TableOptions<T> {
+    name: string;
+    alias?: string;
+    columns: {
+        [K in keyof T]: Column<T[K]>;
+    };
+    indexes?: (this: Fields<T>) => Record<string, {
+        on: Array<Expr<any>>;
+        where?: Expr<boolean>;
+    }>;
+}
+export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
+export declare namespace table {
+    type infer<T> = Table.Infer<T>;
+}