rado 0.1.23 → 0.1.25

package/dist/sqlite/SqliteSchema.d.ts

@@ -1,24 +1,25 @@
-import { SchemaInstructions } from '../lib/Schema';
-import { Statement } from '../lib/Statement';
-export declare namespace SqliteSchema {
-    type Column = {
-        cid: number;
-        name: string;
-        type: string;
-        notnull: number;
-        dflt_value: string | null;
-        pk: number;
-    };
-    interface Index {
-        type: 'index';
-        name: string;
-        tbl_name: string;
-        rootpage: number;
-        sql: string;
-    }
-    function tableData(tableName: string): Statement;
-    function indexData(tableName: string): Statement;
-    function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
-    function columnInstruction(column: Column): [string, string];
-    function indexInstruction(index: Index): [string, string];
-}
+import { Cursor } from '../lib/Cursor';
+import { Expr } from '../lib/Expr';
+import { SchemaInstructions } from '../lib/Schema';
+export declare namespace SqliteSchema {
+    type Column = {
+        cid: number;
+        name: string;
+        type: string;
+        notnull: number;
+        dflt_value: string | null;
+        pk: number;
+    };
+    interface Index {
+        type: 'index';
+        name: string;
+        tbl_name: string;
+        rootpage: number;
+        sql: string;
+    }
+    function tableData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Column>>;
+    function indexData(tableName: Expr<string>): Cursor<Array<SqliteSchema.Index>>;
+    function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
+    function columnInstruction(column: Column): [string, string];
+    function indexInstruction(index: Index): [string, string];
+}

package/dist/sqlite/SqliteSchema.js

@@ -1,15 +1,16 @@
 // src/sqlite/SqliteSchema.ts
-import { Statement, identifier, raw } from "../lib/Statement.js";
+import { Cursor } from "../lib/Cursor.js";
+import { identifier, raw } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {
   const formatter = new SqliteFormatter();
   function tableData(tableName) {
-    return Statement.tag`select * from pragma_table_info(${tableName}) order by cid`;
+    return Cursor.all`select * from pragma_table_info(${tableName}) order by cid`;
   }
   SqliteSchema2.tableData = tableData;
   function indexData(tableName) {
-    return Statement.tag`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
+    return Cursor.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
   }
   SqliteSchema2.indexData = indexData;
   function createInstructions(columnData, indexData2) {
@@ -29,7 +30,7 @@ var SqliteSchema;
       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)[0]
+      ).compile(formatter).sql
     ];
   }
   SqliteSchema2.columnInstruction = columnInstruction;

package/dist/sqlite.d.ts

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

package/package.json

@@ -1,47 +1,47 @@
-{
-  "name": "rado",
-  "version": "0.1.23",
-  "license": "MIT",
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.js",
-    "./*": "./dist/*.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/*"
-      ]
-    }
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsx build.ts",
-    "test": "tsx test",
-    "prepublishOnly": "tsc -p tsconfig.build.json && tsx build.ts"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^5.4.1",
-    "@types/glob": "^8.0.0",
-    "@types/sql.js": "^1.4.2",
-    "better-sqlite3": "^7.5.1",
-    "esbuild": "^0.16.16",
-    "glob": "^8.0.3",
-    "sade": "^1.8.1",
-    "sql.js": "^1.8.0",
-    "sqlite3": "^5.1.4",
-    "tsx": "^3.12.1",
-    "typescript": "next",
-    "uvu": "^0.5.6"
-  },
-  "volta": {
-    "node": "18.12.1"
-  },
-  "packageManager": "yarn@3.3.1",
-  "resolutions": {
-    "esbuild": "0.16.16"
-  }
-}
+{
+  "name": "rado",
+  "version": "0.1.25",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsx build.ts",
+    "test": "tsx test",
+    "prepublishOnly": "tsc -p tsconfig.build.json && tsx build.ts"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^5.4.1",
+    "@types/glob": "^8.0.0",
+    "@types/sql.js": "^1.4.2",
+    "better-sqlite3": "^7.5.1",
+    "esbuild": "^0.16.16",
+    "glob": "^8.0.3",
+    "sade": "^1.8.1",
+    "sql.js": "^1.8.0",
+    "sqlite3": "^5.1.4",
+    "tsx": "^3.12.1",
+    "typescript": "next",
+    "uvu": "^0.5.6"
+  },
+  "volta": {
+    "node": "18.12.1"
+  },
+  "packageManager": "yarn@3.3.1",
+  "resolutions": {
+    "esbuild": "0.16.16"
+  }
+}

package/dist/Column.d.ts

@@ -1,41 +0,0 @@
-export declare const enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-export interface ColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: any;
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-}
-export declare class Column<T = any> {
-    data: ColumnData;
-    constructor(data: ColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<T & Column.Optional>;
-    primaryKey(): Column<T & Column.Optional>;
-    unique(): Column<T>;
-    defaultValue(value: T): Column<T & Column.Optional>;
-}
-export declare namespace Column {
-    const isOptional: unique symbol;
-    export type Optional = {
-        [isOptional]: true;
-    };
-    export {};
-}
-export declare const column: {
-    string<T extends string = string>(): Column<T>;
-    integer<T_1 extends number = number>(): Column<T_1>;
-    number<T_2 extends number = number>(): Column<T_2>;
-    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
-    object<T_4 extends object = object>(): Column<T_4>;
-    array<T_5 = any>(): Column<T_5[]>;
-};

package/dist/Column.js

@@ -1,58 +0,0 @@
-// src/Column.ts
-var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
-  ColumnType2["String"] = "String";
-  ColumnType2["Integer"] = "Integer";
-  ColumnType2["Number"] = "Number";
-  ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Object"] = "Object";
-  ColumnType2["Array"] = "Array";
-  return ColumnType2;
-})(ColumnType || {});
-var Column = class {
-  constructor(data) {
-    this.data = data;
-  }
-  name(name) {
-    return new Column({ ...this.data, name });
-  }
-  nullable() {
-    return new Column({ ...this.data, nullable: true });
-  }
-  autoIncrement() {
-    return new Column({ ...this.data, autoIncrement: true });
-  }
-  primaryKey() {
-    return new Column({ ...this.data, primaryKey: true });
-  }
-  unique() {
-    return new Column({ ...this.data, unique: true });
-  }
-  defaultValue(value) {
-    return new Column({ ...this.data, defaultValue: value });
-  }
-};
-var column = {
-  string() {
-    return new Column({ type: "String" /* String */ });
-  },
-  integer() {
-    return new Column({ type: "Integer" /* Integer */ });
-  },
-  number() {
-    return new Column({ type: "Number" /* Number */ });
-  },
-  boolean() {
-    return new Column({ type: "Boolean" /* Boolean */ });
-  },
-  object() {
-    return new Column({ type: "Object" /* Object */ });
-  },
-  array() {
-    return new Column({ type: "Array" /* Array */ });
-  }
-};
-export {
-  Column,
-  ColumnType,
-  column
-};

package/dist/Cursor.d.ts

@@ -1,77 +0,0 @@
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
-export declare class Cursor<T> {
-    /** @internal */
-    protected __cursorType: T;
-    constructor(query: Query<T>);
-    query(): Query<T>;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Limitable<T> extends Cursor<T> {
-        take(limit: number | undefined): Limitable<T>;
-        skip(offset: number | undefined): Limitable<T>;
-    }
-    class Filterable<T> extends Limitable<T> {
-        where(...where: Array<EV<boolean>>): Filterable<T>;
-    }
-    class Delete<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-    }
-    class Update<T> extends Filterable<{
-        rowsAffected: number;
-    }> {
-        query: () => Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class InsertValues extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Insert;
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
-    }
-    class Create extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        constructor(queries: Array<Query>);
-    }
-    class SelectMultiple<T> extends Filterable<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Filterable<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        toExpr(): Expr<T>;
-    }
-}

package/dist/Cursor.js

@@ -1,211 +0,0 @@
-// src/Cursor.ts
-import { Expr, ExprData } from "./Expr";
-import { Functions } from "./Functions";
-import { Query } from "./Query";
-import { Target } from "./Target";
-var Cursor = class {
-  constructor(query) {
-    Object.defineProperty(this, "query", {
-      enumerable: false,
-      value: () => query
-    });
-  }
-  query() {
-    throw new Error("Not implemented");
-  }
-  toJSON() {
-    return this.query();
-  }
-};
-((Cursor2) => {
-  class Limitable extends Cursor2 {
-    take(limit) {
-      return new Limitable({ ...this.query(), limit });
-    }
-    skip(offset) {
-      return new Limitable({ ...this.query(), offset });
-    }
-  }
-  Cursor2.Limitable = Limitable;
-  class Filterable extends Limitable {
-    where(...where) {
-      const condition = Expr.and(...where);
-      const query = this.query();
-      return new Filterable({
-        ...query,
-        where: (query.where ? condition.and(new Expr(query.where)) : condition).expr
-      });
-    }
-  }
-  Cursor2.Filterable = Filterable;
-  class Delete extends Filterable {
-    query() {
-      return super.query();
-    }
-  }
-  Cursor2.Delete = Delete;
-  class Update extends Filterable {
-    set(set) {
-      return new Update({ ...this.query(), set });
-    }
-  }
-  Cursor2.Update = Update;
-  class InsertValuesReturning extends Cursor2 {
-  }
-  Cursor2.InsertValuesReturning = InsertValuesReturning;
-  class InsertValues extends Cursor2 {
-    query() {
-      return super.query();
-    }
-    returning(selection) {
-      return new InsertValuesReturning(
-        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
-      );
-    }
-  }
-  Cursor2.InsertValues = InsertValues;
-  class Insert {
-    constructor(into) {
-      this.into = into;
-    }
-    values(...data) {
-      return new InsertValues(Query.Insert({ into: this.into, data }));
-    }
-  }
-  Cursor2.Insert = Insert;
-  class Create extends Cursor2 {
-    constructor(table) {
-      super(Query.CreateTable({ table, ifNotExists: true }));
-      this.table = table;
-    }
-  }
-  Cursor2.Create = Create;
-  class Batch extends Cursor2 {
-    constructor(queries) {
-      super(Query.Batch({ queries }));
-      this.queries = queries;
-    }
-  }
-  Cursor2.Batch = Batch;
-  class SelectMultiple extends Filterable {
-    query() {
-      return super.query();
-    }
-    leftJoin(that, ...on) {
-      const query = this.query();
-      return new SelectMultiple({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "left",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this.query();
-      return new SelectMultiple({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "inner",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    select(selection) {
-      return new SelectMultiple({
-        ...this.query(),
-        selection: ExprData.create(selection)
-      });
-    }
-    count() {
-      return new SelectSingle({
-        ...this.query(),
-        selection: Functions.count().expr,
-        singleResult: true
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectMultiple({
-        ...this.query(),
-        orderBy
-      });
-    }
-    groupBy(...groupBy) {
-      return new SelectMultiple({
-        ...this.query(),
-        groupBy: groupBy.map(ExprData.create)
-      });
-    }
-    first() {
-      return new SelectSingle({ ...this.query(), singleResult: true });
-    }
-    where(...where) {
-      return new SelectMultiple(super.where(...where).query());
-    }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
-    }
-  }
-  Cursor2.SelectMultiple = SelectMultiple;
-  class SelectSingle extends Filterable {
-    query() {
-      return super.query();
-    }
-    leftJoin(that, ...on) {
-      const query = this.query();
-      return new SelectSingle({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "left",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    innerJoin(that, ...on) {
-      const query = this.query();
-      return new SelectSingle({
-        ...query,
-        from: Target.Join(
-          query.from,
-          Target.Table(that.data()),
-          "inner",
-          Expr.and(...on).expr
-        )
-      });
-    }
-    select(selection) {
-      return new SelectSingle({
-        ...this.query(),
-        selection: ExprData.create(selection)
-      });
-    }
-    orderBy(...orderBy) {
-      return new SelectSingle({
-        ...this.query(),
-        orderBy
-      });
-    }
-    groupBy(...groupBy) {
-      return new SelectSingle({
-        ...this.query(),
-        groupBy: groupBy.map(ExprData.create)
-      });
-    }
-    where(...where) {
-      return new SelectSingle(super.where(...where).query());
-    }
-    toExpr() {
-      return new Expr(ExprData.Query(this.query()));
-    }
-  }
-  Cursor2.SelectSingle = SelectSingle;
-})(Cursor || (Cursor = {}));
-export {
-  Cursor
-};

package/dist/Driver.d.ts

@@ -1,72 +0,0 @@
-import { Cursor } from './Cursor';
-import { Formatter } from './Formatter';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    all(strings: TemplateStringsArray, ...params: Array<any>): any;
-    get(strings: TemplateStringsArray, ...params: Array<any>): any;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-export declare namespace Driver {
-    export interface Sync {
-        <T>(query: Cursor<T>): T;
-        (strings: TemplateStringsArray, ...values: any[]): any;
-    }
-    export abstract class Sync extends DriverBase {
-        transactionId: number;
-        abstract rows(stmt: Statement.Compiled): Array<object>;
-        abstract values(stmt: Statement.Compiled): Array<Array<any>>;
-        abstract execute(stmt: Statement.Compiled): void;
-        abstract mutate(stmt: Statement.Compiled): {
-            rowsAffected: number;
-        };
-        abstract schema(tableName: string): Schema;
-        executeQuery<T>(query: Query<T>): T;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-        transaction<T>(run: (query: Sync) => T): T;
-        toAsync(): SyncWrapper;
-    }
-    export interface Async {
-        <T>(query: Cursor<T>): Promise<T>;
-        (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-    }
-    export abstract class Async extends DriverBase {
-        transactionId: number;
-        abstract isolate(): [connection: Async, release: () => Promise<void>];
-        abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        abstract execute(stmt: Statement.Compiled): Promise<void>;
-        abstract mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        abstract schema(tableName: string): Promise<Schema>;
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-        transaction<T>(run: (query: Async) => T): Promise<T>;
-    }
-    class SyncWrapper extends Async {
-        private sync;
-        lock: Promise<void> | undefined;
-        constructor(sync: Sync);
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        execute(stmt: Statement.Compiled): Promise<void>;
-        mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        schema(tableName: string): Promise<Schema>;
-        isolate(): [connection: Async, release: () => Promise<void>];
-    }
-    export {};
-}
-export {};