rado 0.1.23 → 0.1.25

package/dist/Query.js

@@ -1,57 +0,0 @@
-// 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

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

package/dist/Schema.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,184 +0,0 @@
-// 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

@@ -1,47 +0,0 @@
-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

@@ -1,82 +0,0 @@
-// 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

@@ -1,30 +0,0 @@
-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

@@ -1,37 +0,0 @@
-// 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

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

package/dist/sqlite/index.d.ts

@@ -1,2 +0,0 @@
-export * from './SqliteFormatter';
-export * from './SqliteFunctions';

package/dist/sqlite/index.js

@@ -1,3 +0,0 @@
-// src/sqlite/index.ts
-export * from "./SqliteFormatter";
-export * from "./SqliteFunctions";