rado 0.1.22 → 0.1.23

package/dist/Query.js

@@ -0,0 +1,57 @@
+// src/Query.ts
+var QueryType = /* @__PURE__ */ ((QueryType2) => {
+  QueryType2["Insert"] = "Insert";
+  QueryType2["Select"] = "Select";
+  QueryType2["Update"] = "Update";
+  QueryType2["Delete"] = "Delete";
+  QueryType2["CreateTable"] = "CreateTable";
+  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 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) {
+    return { type: "Raw" /* Raw */, ...raw };
+  }
+  Query2.Raw = Raw;
+})(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,10 @@
+import { ColumnData } from './Column';
+import { Query } from './Query';
+export interface Schema {
+    name: string;
+    alias?: string;
+    columns: Record<string, ColumnData>;
+}
+export declare namespace Schema {
+    function diff(a: Schema, b: Schema): Array<Query.AlterTable>;
+}

package/dist/Selection.d.ts

@@ -0,0 +1,18 @@
+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 {
+    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/Statement.d.ts

@@ -0,0 +1,57 @@
+import { Sanitizer } from './Sanitizer';
+declare const 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 ofTemplate(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.escapeIdent(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,47 @@
+import { Column } from './Column';
+import { Cursor } from './Cursor';
+import { Expr } from './Expr';
+import { Fields } from './Fields';
+import { Schema } from './Schema';
+import { Update } from './Update';
+export declare class Table<T> extends Cursor.SelectMultiple<T> {
+    /** @internal */
+    protected __tableType: T;
+    constructor(schema: Schema);
+    insertOne(record: Table.Insert<T>): Cursor.Batch<T>;
+    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
+    set(data: Update<T>): Cursor.Update<T>;
+    createTable(): Cursor.Create;
+    as(alias: string): Table<T> & Fields<T>;
+    get(name: string): Expr<any>;
+    toExpr(): Expr<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.Optional ? K : never;
+    }[keyof T];
+    type RequiredKeys<T> = {
+        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Optional ? 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 {};
+}
+export interface TableOptions<T> {
+    name: string;
+    alias?: string;
+    columns: {
+        [K in keyof T]: Column<T[K]>;
+    };
+    indexes?: Record<string, Array<Expr<any>>>;
+}
+export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
+export declare namespace table {
+    type infer<T> = T extends Table<infer U> ? U : never;
+}

package/dist/Table.js

@@ -0,0 +1,82 @@
+// src/Table.ts
+import { Cursor } from "./Cursor";
+import { Expr, ExprData } from "./Expr";
+import { Query } from "./Query";
+import { Target } from "./Target";
+var Table = class extends Cursor.SelectMultiple {
+  constructor(data) {
+    super(
+      Query.Select({
+        from: Target.Table(data),
+        selection: ExprData.Row(Target.Table(data))
+      })
+    );
+    Object.defineProperty(this, "data", {
+      enumerable: false,
+      value: () => data
+    });
+    if (data.columns)
+      for (const column of Object.keys(data.columns)) {
+        Object.defineProperty(this, column, {
+          enumerable: true,
+          get: () => this.get(column)
+        });
+      }
+    return new Proxy(this, {
+      get(target, key) {
+        return key in target ? target[key] : target.get(key);
+      }
+    });
+  }
+  insertOne(record) {
+    return new Cursor.Batch([
+      Query.Insert({
+        into: this.data(),
+        data: [record],
+        selection: ExprData.Row(Target.Table(this.data())),
+        singleResult: true
+      })
+    ]);
+  }
+  insertAll(data) {
+    return new Cursor.Insert(this.data()).values(...data);
+  }
+  set(data) {
+    return new Cursor.Update(
+      Query.Update({
+        table: this.data()
+      })
+    ).set(data);
+  }
+  createTable() {
+    return new Cursor.Create(this.data());
+  }
+  as(alias) {
+    return new Table({ ...this.data(), alias });
+  }
+  get(name) {
+    return new Expr(ExprData.Field(this.toExpr().expr, name));
+  }
+  toExpr() {
+    return new Expr(ExprData.Row(Target.Table(this.data())));
+  }
+  /** @internal */
+  data() {
+    throw new Error("Not implemented");
+  }
+};
+function table(options) {
+  return new Table({
+    ...options,
+    columns: Object.fromEntries(
+      Object.entries(options.columns).map(([key, column]) => {
+        const { data } = column;
+        return [key, { ...data, name: data.name || key }];
+      })
+    )
+  });
+}
+export {
+  Table,
+  table
+};

package/dist/Target.d.ts

@@ -0,0 +1,30 @@
+import { ExprData } from './Expr';
+import { Schema } from './Schema';
+export declare const enum TargetType {
+    Each = "Each",
+    Table = "Table",
+    Join = "Join"
+}
+export type Target = Target.Each | Target.Table | Target.Join;
+export declare namespace Target {
+    interface Each {
+        type: TargetType.Each;
+        expr: ExprData;
+        alias: string;
+    }
+    function Each(expr: ExprData, alias: string): Each;
+    interface Table {
+        type: TargetType.Table;
+        table: Schema;
+    }
+    function Table(table: Schema): Table;
+    interface Join {
+        type: TargetType.Join;
+        left: Target;
+        right: Target;
+        joinType: 'left' | 'inner';
+        on: ExprData;
+    }
+    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
+    function source(from: Target): Schema | undefined;
+}

package/dist/Target.js

@@ -0,0 +1,37 @@
+// src/Target.ts
+var TargetType = /* @__PURE__ */ ((TargetType2) => {
+  TargetType2["Each"] = "Each";
+  TargetType2["Table"] = "Table";
+  TargetType2["Join"] = "Join";
+  return TargetType2;
+})(TargetType || {});
+var Target;
+((Target2) => {
+  function Each(expr, alias) {
+    return { type: "Each" /* Each */, expr, alias };
+  }
+  Target2.Each = Each;
+  function Table(table) {
+    return { type: "Table" /* Table */, table };
+  }
+  Target2.Table = Table;
+  function Join(left, right, joinType, on) {
+    return { type: "Join" /* Join */, left, right, joinType, on };
+  }
+  Target2.Join = Join;
+  function source(from) {
+    switch (from.type) {
+      case "Table" /* Table */:
+        return from.table;
+      case "Join" /* Join */:
+        return source(from.left);
+      default:
+        return void 0;
+    }
+  }
+  Target2.source = source;
+})(Target || (Target = {}));
+export {
+  Target,
+  TargetType
+};

package/dist/Update.d.ts

@@ -0,0 +1,4 @@
+import type { EV } from './Expr';
+export type Update<Row> = Partial<{
+    [K in keyof Row]: EV<Row[K]>;
+}>;

package/dist/driver/better-sqlite3.d.ts

@@ -1,17 +1,17 @@
-import type { Database } from 'better-sqlite3';
-import { Driver } from '../lib/Driver';
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare class BetterSqlite3Driver extends Driver.Sync {
-    db: Database;
-    constructor(db: Database);
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
-    values([sql, params]: Statement.Compiled): Array<Array<any>>;
-    execute([sql, params]: Statement.Compiled): void;
-    mutate([sql, params]: Statement.Compiled): {
-        rowsAffected: number;
-    };
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): BetterSqlite3Driver;
+import type { Database } from 'better-sqlite3';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
+export declare class BetterSqlite3Driver extends Driver.Sync {
+    db: Database;
+    constructor(db: Database);
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
+    values([sql, params]: Statement.Compiled): Array<Array<any>>;
+    execute([sql, params]: Statement.Compiled): void;
+    mutate([sql, params]: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): BetterSqlite3Driver;

package/dist/driver/sql.js.d.ts

@@ -1,17 +1,17 @@
-import type { Database } from 'sql.js';
-import { Driver } from '../lib/Driver';
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare class SqlJsDriver extends Driver.Sync {
-    db: Database;
-    constructor(db: Database);
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
-    values([sql, params]: Statement.Compiled): Array<Array<any>>;
-    execute([sql, params]: Statement.Compiled): void;
-    mutate([sql, params]: Statement.Compiled): {
-        rowsAffected: number;
-    };
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): SqlJsDriver;
+import type { Database } from 'sql.js';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
+export declare class SqlJsDriver extends Driver.Sync {
+    db: Database;
+    constructor(db: Database);
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Array<T>;
+    values([sql, params]: Statement.Compiled): Array<Array<any>>;
+    execute([sql, params]: Statement.Compiled): void;
+    mutate([sql, params]: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): SqlJsDriver;

package/dist/driver/sqlite3.d.ts

@@ -1,20 +1,20 @@
-import type { Database } from 'sqlite3';
-import { Driver } from '../lib/Driver';
-import { Query } from '../lib/Query';
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare class Sqlite3Driver extends Driver.Async {
-    private db;
-    lock: Promise<void> | undefined;
-    constructor(db: Database);
-    executeQuery<T>(query: Query<T>): Promise<T>;
-    rows<T extends object = object>([sql, params]: Statement.Compiled): Promise<Array<T>>;
-    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-    execute([sql, params]: Statement.Compiled): Promise<void>;
-    mutate([sql, params]: Statement.Compiled): Promise<{
-        rowsAffected: number;
-    }>;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
-}
-export declare function connect(db: Database): Sqlite3Driver;
+import type { Database } from 'sqlite3';
+import { Driver } from '../lib/Driver';
+import { Query } from '../lib/Query';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
+export declare class Sqlite3Driver extends Driver.Async {
+    private db;
+    lock: Promise<void> | undefined;
+    constructor(db: Database);
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    rows<T extends object = object>([sql, params]: Statement.Compiled): Promise<Array<T>>;
+    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    execute([sql, params]: Statement.Compiled): Promise<void>;
+    mutate([sql, params]: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+}
+export declare function connect(db: Database): Sqlite3Driver;