rado 0.1.28 → 0.1.30

package/dist/lib/Schema.js

@@ -1,5 +1,6 @@
 // src/lib/Schema.ts
 import { Query } from "./Query.js";
+import { Statement } from "./Statement.js";
 var Schema;
 ((Schema2) => {
   function create(schema) {
@@ -27,7 +28,10 @@ var Schema;
       } else if (!schemaCol) {
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
-        const { sql: instruction } = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        const { sql: instruction } = formatter.formatColumn(
+          { stmt: new Statement() },
+          { ...schemaCol, references: void 0 }
+        ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
@@ -46,6 +50,7 @@ var Schema;
         res.unshift(Query.DropIndex({ table: schema, name: indexName }));
       } else {
         const { sql: instruction } = formatter.formatCreateIndex(
+          { stmt: new Statement() },
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {

package/dist/lib/Statement.d.ts

@@ -25,30 +25,26 @@ export interface CompileOptions {
 }
 export declare class Statement {
     tokens: Array<Token>;
-    constructor(tokens: Array<Token>);
-    concat(...tokens: Array<Token | Statement>): Statement;
-    static create(from: string | Statement): Statement;
+    constructor(tokens?: Array<Token>);
+    concat(...tokens: Array<Token>): this;
     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;
+    space(): this;
+    add(addition: undefined | string): this;
+    addLine(addition: undefined | string): this;
+    indent(): this;
+    dedent(): this;
+    newline(ignore?: boolean): this;
+    identifier(name: string): this;
+    addIdentifier(name: string): this;
+    value(value: any): this;
+    addValue(value: any): this;
+    param(name: string): this;
+    addParam(name: string): this;
+    raw(query: string): this;
+    openParenthesis(): this;
+    closeParenthesis(): this;
+    call<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
     isEmpty(): boolean;
     compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
 }
@@ -60,13 +56,4 @@ export declare class CompiledStatement {
     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

@@ -24,58 +24,39 @@ var Token = class {
     return new Token("Param" /* Param */, name);
   }
 };
-var SEPARATE = ",";
+var SEPARATE = ", ";
 var WHITESPACE = " ";
 var NEWLINE = "\n";
 var Statement = class {
-  constructor(tokens) {
+  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;
+    this.tokens.push(...tokens);
+    return this;
   }
   static tag(strings, params) {
     return new Statement(
       strings.flatMap((s, i) => {
-        const param2 = params[i];
-        return [Token.Raw(s)].concat(param2 ? param2.tokens : []);
+        const param = params[i];
+        return [Token.Raw(s)].concat(param ? param.tokens : []);
       })
     );
   }
   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);
+    if (this.tokens.length === 0)
+      return this;
+    return this.raw(WHITESPACE);
   }
   add(addition) {
     if (!addition)
       return this;
-    if (addition instanceof Statement && addition.isEmpty())
-      return this;
-    return this.space().concat(Statement.create(addition));
+    return this.space().raw(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);
+    return this.newline().add(addition);
   }
   indent() {
     return this.concat(Token.Indent());
@@ -94,11 +75,11 @@ var Statement = class {
   addIdentifier(name) {
     return this.space().identifier(name);
   }
-  value(value2) {
-    return this.concat(Token.Value(value2));
+  value(value) {
+    return this.concat(Token.Value(value));
   }
-  addValue(value2) {
-    return this.space().value(value2);
+  addValue(value) {
+    return this.space().value(value);
   }
   param(name) {
     return this.concat(Token.Param(name));
@@ -111,21 +92,23 @@ var Statement = class {
       return this;
     return this.concat(Token.Raw(query));
   }
-  parenthesis(inner) {
-    return this.raw("(").indent().newline().concat(Statement.create(inner)).dedent().newline().raw(")");
+  openParenthesis() {
+    return this.raw("(").indent().newline();
   }
-  addParenthesis(stmnt) {
-    return this.space().parenthesis(stmnt);
+  closeParenthesis() {
+    return this.dedent().newline().raw(")");
   }
-  separated(input, separator = SEPARATE) {
-    return this.concat(
-      ...input.flatMap(
-        (stmt, i) => i === 0 ? stmt.tokens : [Token.Raw(separator), Token.Raw(NEWLINE), ...stmt.tokens]
-      )
-    );
+  *call(parts, separator = SEPARATE) {
+    this.openParenthesis();
+    yield* this.separate(parts, separator);
+    this.closeParenthesis();
   }
-  addSeparated(input, separator = SEPARATE) {
-    return this.space().separated(input, separator);
+  *separate(parts, separator = SEPARATE) {
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0)
+        this.raw(separator).newline();
+      yield parts[i];
+    }
   }
   isEmpty() {
     return this.tokens.length === 0 || this.tokens.length === 1 && this.tokens[0].type === "Raw" /* Raw */ && this.tokens[0].data === "";
@@ -173,56 +156,20 @@ var CompiledStatement = class {
     this.paramData = paramData;
   }
   params(input) {
-    return this.paramData.map((param2) => {
-      if (param2.type === ParamType.Named) {
-        if (input && param2.name in input)
-          return this.sanitizer.formatParamValue(input[param2.name]);
-        throw new TypeError(`Missing parameter ${param2.name}`);
+    return this.paramData.map((param) => {
+      if (param.type === ParamType.Named) {
+        if (input && param.name in input)
+          return this.sanitizer.formatParamValue(input[param.name]);
+        throw new TypeError(`Missing parameter ${param.name}`);
       }
-      return this.sanitizer.formatParamValue(param2.value);
+      return this.sanitizer.formatParamValue(param.value);
     });
   }
   toString() {
     return this.sql;
   }
 };
-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 param(name) {
-  return new Statement([Token.Param(name)]);
-}
-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 {
   CompiledStatement,
-  Statement,
-  call,
-  empty,
-  identifier,
-  newline,
-  param,
-  parenthesis,
-  raw,
-  separated,
-  value
+  Statement
 };

package/dist/lib/Table.d.ts

@@ -9,7 +9,7 @@ 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>>;
+    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
     set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
     delete(): Cursor.Delete;

package/dist/lib/Table.js

@@ -33,14 +33,14 @@ var Table = class extends Cursor.SelectMultiple {
     });
   }
   insertOne(record) {
-    return new Cursor.Batch([
+    return new Cursor(
       Query.Insert({
         into: this.schema(),
         data: [record],
         selection: ExprData.Row(Target.Table(this.schema())),
         singleResult: true
       })
-    ]);
+    );
   }
   insertAll(data) {
     return new Cursor.Insert(this.schema()).values(...data);

package/dist/sqlite/SqliteFormatter.d.ts

@@ -6,7 +6,6 @@ export declare class SqliteFormatter extends Formatter {
     escapeValue(value: any): string;
     escapeIdentifier(input: string): string;
     escapeString(input: string): string;
-    formatSqlAccess(on: Statement, field: string): Statement;
-    formatJsonAccess(on: Statement, field: string): Statement;
-    formatExpr(expr: ExprData, ctx: FormatContext): Statement;
+    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
 }

package/dist/sqlite/SqliteFormatter.js

@@ -1,7 +1,6 @@
 // src/sqlite/SqliteFormatter.ts
 import { ExprType } from "../lib/Expr.js";
 import { Formatter } from "../lib/Formatter.js";
-import { identifier } from "../lib/Statement.js";
 import { TargetType } from "../lib/Target.js";
 function escapeWithin(input, outer) {
   let buf = outer;
@@ -43,15 +42,14 @@ var SqliteFormatter = class extends Formatter {
   escapeString(input) {
     return escapeWithin(input, "'");
   }
-  formatSqlAccess(on, field) {
-    const target = this.formatString(`$.${field}`);
-    return on.raw("->>").concat(target);
+  formatAccess(ctx, mkSubject, field) {
+    const { stmt, formatAsJson } = ctx;
+    mkSubject();
+    stmt.raw(formatAsJson ? "->" : "->>");
+    return this.formatString(ctx, `$.${field}`);
   }
-  formatJsonAccess(on, field) {
-    const target = this.formatString(`$.${field}`);
-    return on.raw("->").concat(target);
-  }
-  formatExpr(expr, ctx) {
+  formatExpr(ctx, expr) {
+    const { stmt } = ctx;
     switch (expr.type) {
       case ExprType.Call:
         if (expr.method === "match") {
@@ -60,10 +58,12 @@ var SqliteFormatter = class extends Formatter {
             throw new Error("not implemented");
           if (from.target.type !== TargetType.Table)
             throw new Error("not implemented");
-          return identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ").concat(this.formatExprValue(query, ctx));
+          stmt.identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ");
+          this.formatExprValue(ctx, query);
+          return stmt;
         }
       default:
-        return super.formatExpr(expr, ctx);
+        return super.formatExpr(ctx, expr);
     }
   }
 };

package/dist/sqlite/SqliteSchema.js

@@ -1,6 +1,6 @@
 // src/sqlite/SqliteSchema.ts
 import { Cursor } from "../lib/Cursor.js";
-import { identifier, raw } from "../lib/Statement.js";
+import { Statement } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {
@@ -25,13 +25,16 @@ var SqliteSchema;
   }
   SqliteSchema2.createInstructions = createInstructions;
   function columnInstruction(column) {
-    return [
-      column.name,
-      identifier(column.name).add(column.type).addIf(column.pk === 1, "PRIMARY KEY").addIf(column.notnull === 1, "NOT NULL").addIf(
-        column.dflt_value !== null,
-        raw("DEFAULT").addParenthesis(column.dflt_value)
-      ).compile(formatter).sql
-    ];
+    const stmt = new Statement();
+    stmt.identifier(column.name).add(column.type);
+    if (column.pk === 1)
+      stmt.add("PRIMARY KEY");
+    if (column.notnull === 1)
+      stmt.add("NOT NULL");
+    if (column.dflt_value !== null) {
+      stmt.add("DEFAULT").space().openParenthesis().raw(column.dflt_value).closeParenthesis();
+    }
+    return [column.name, stmt.compile(formatter).sql];
   }
   SqliteSchema2.columnInstruction = columnInstruction;
   function indexInstruction(index) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "license": "MIT",
   "type": "module",
   "exports": {