rado 0.3.2 → 0.3.4

package/dist/test/TestFts5.js

@@ -0,0 +1,34 @@
+// test/TestFts5.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, table } from "../src/index.js";
+import { match } from "../src/sqlite.js";
+import { connect } from "./DbSuite.js";
+var Search = table({
+  name: "Search",
+  columns: {
+    name: column.string(),
+    col2: column.string().nullable()
+  }
+});
+test("Search", async () => {
+  if (process.env.TEST_DRIVER === "sql.js")
+    return;
+  const query = await connect();
+  await query`
+    create virtual table if not exists Search using fts5(name, col2)
+  `;
+  await query(
+    Search.insertAll([
+      { name: "test" },
+      { name: "hello" },
+      { name: "world", col2: "test ok" }
+    ])
+  );
+  const results = await query(Search.where(match(Search, "test")));
+  assert.equal(
+    results.map((res) => res.name),
+    ["test", "world"]
+  );
+});
+test.run();

package/dist/test/TestFunctions.js

@@ -0,0 +1,28 @@
+// test/TestFunctions.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, table } from "../src/index.js";
+import { cast, strftime } from "../src/sqlite.js";
+import { connect } from "./DbSuite.js";
+test("Functions", async () => {
+  const query = await connect();
+  const User = table({
+    name: "User",
+    columns: {
+      id: column.integer().primaryKey(),
+      birthdate: column.string()
+    }
+  });
+  await query(User.createTable());
+  const now = "1920-01-01";
+  const int = (e) => cast(e, "integer");
+  const age = int(strftime("%Y", now)).substract(int(strftime("%Y", User.birthdate))).substract(
+    int(strftime("%m-%d", now).less(strftime("%m-%d", User.birthdate)))
+  );
+  const me = await query(User.insertOne({ birthdate: "1900-01-01" }));
+  assert.is(
+    (await query(User.sure().select({ age }).where(User.id.is(me.id)))).age,
+    20
+  );
+});
+test.run();

package/dist/test/TestJoins.js

@@ -0,0 +1,34 @@
+// test/TestJoins.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, create, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+var User = table({
+  name: "User",
+  columns: {
+    id: column.integer().primaryKey(),
+    name: column.string()
+  }
+});
+var Contact = table({
+  name: "Contact",
+  columns: {
+    id: column.integer().primaryKey(),
+    user: column.integer()
+  }
+});
+test("OrderBy", async () => {
+  const query = await connect();
+  await query.transaction(async (query2) => {
+    await query2(create(User, Contact));
+    const user1 = await query2(User.insertOne({ name: "b" }));
+    const user2 = await query2(User.insertOne({ name: "a" }));
+    await query2(Contact.insertAll([{ user: user1.id }, { user: user2.id }]));
+  });
+  const results = await query(
+    Contact.leftJoin(User, User.id.is(Contact.user)).select({ ...Contact, user: User }).orderBy(User.name)
+  );
+  assert.is(results[0].user.name, "a");
+  assert.is(results[1].user.name, "b");
+});
+test.run();

package/dist/test/TestJson.js

@@ -0,0 +1,33 @@
+// test/TestJson.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { Cursor, Expr, column, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+var Node = table({
+  name: "node",
+  columns: {
+    id: column.integer().primaryKey(),
+    index: column.integer()
+  }
+});
+test("json", async () => {
+  const query = await connect();
+  await query(Node.createTable());
+  const amount = 10;
+  const objects = Array.from({ length: amount }).map((_, i) => ({ index: i }));
+  assert.is(objects.length, amount);
+  await query(Node.insertAll(objects));
+  const count = await query(Node.count());
+  assert.is(count, amount);
+  const q = Node.first().select({
+    fieldA: Expr.value(12),
+    fieldB: Node.index
+  }).where(Node.index.is(1));
+  const res1 = await query(q);
+  assert.is(res1.fieldA, 12);
+  assert.is(res1.fieldB, 1);
+  const res2 = await query(new Cursor(q.toJSON()));
+  assert.is(res2.fieldA, 12);
+  assert.is(res2.fieldB, 1);
+});
+test.run();

package/dist/test/TestPrepare.js

@@ -0,0 +1,27 @@
+// test/TestPrepare.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+var Node = table({
+  name: "node",
+  columns: {
+    id: column.integer().primaryKey(),
+    index: column.integer()
+  }
+});
+test("prepare", async () => {
+  const query = await connect();
+  await query(Node.createTable());
+  const amount = 10;
+  const objects = Array.from({ length: amount }).map((_, i) => ({ index: i }));
+  const insert = query.prepare((index) => {
+    return Node.insertAll([{ index }]);
+  });
+  for (const object of objects) {
+    await insert(object.index);
+  }
+  const total = await query(Node.count());
+  assert.is(amount, total);
+});
+test.run();

package/dist/test/TestRawSql.js

@@ -0,0 +1,31 @@
+// test/TestRawSql.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { connect } from "./DbSuite.js";
+var query = await connect();
+var valueWithQuotes = `test"t'est`;
+test("Get row", async () => {
+  assert.equal(await query.get`select ${valueWithQuotes} as res`, {
+    res: valueWithQuotes
+  });
+});
+test("Get rows", async () => {
+  assert.equal(
+    await query.all`
+      with recursive
+        cnt(x) as (values(${1}) union all select x+${1} from cnt where x<3)
+      select x from cnt;
+    `,
+    [{ x: 1 }, { x: 2 }, { x: 3 }]
+  );
+});
+test("Execute", async () => {
+  await query(
+    query.sql`create table test (id integer primary key, name text)`,
+    query.sql`insert into test (name) values (${valueWithQuotes})`
+  );
+  assert.equal(await query.all`select * from test`, [
+    { id: 1, name: valueWithQuotes }
+  ]);
+});
+test.run();

package/dist/test/TestSchema.js

@@ -0,0 +1,69 @@
+// test/TestSchema.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, index, table } from "../src/index.js";
+import { datetime } from "../src/sqlite.js";
+import { connect } from "./DbSuite.js";
+var columns = {
+  id: column.integer().primaryKey(),
+  index: column.integer(),
+  bool: column.boolean(),
+  string: column.string(),
+  number: column.number(),
+  array: column.array(),
+  object: column.object(),
+  nullableCol: column.string().nullable(),
+  defaultString: column.string().defaultValue("'with quotes'"),
+  defaultNumber: column.number().defaultValue(123),
+  defaultBoolean: column.boolean().defaultValue(true),
+  defaultBoolean2: column.boolean().defaultValue(false),
+  defaultFloat: column.number().defaultValue(1.23),
+  defaultArray: column.array().defaultValue([1, 2, 3]),
+  defaultObject: column.object().defaultValue({ a: 1, b: 2, c: 3 }),
+  createdAt: column.string().defaultValue(datetime("now", "localtime"))
+};
+var TestTable = table({
+  name: "test",
+  columns
+});
+var query = await connect();
+test("Create table", async () => {
+  await query(TestTable.createTable());
+});
+test("Add col", async () => {
+  const createdAt = column.string().defaultValue(datetime("now", "localtime"));
+  const Start = table({
+    name: "test",
+    columns: {
+      id: column.integer().primaryKey(),
+      createdAt,
+      text: column.string()
+    }
+  });
+  await query(Start.createTable());
+  const AddCol = table({
+    name: "test",
+    columns: {
+      id: column.integer().primaryKey(),
+      createdAt,
+      newCol: column.string()
+    },
+    indexes() {
+      return {
+        newCol: index(this.newCol),
+        multiple: index(this.newCol.concat("inline parameter test"))
+      };
+    }
+  });
+  await query.migrateSchema(AddCol);
+  await query(
+    AddCol.insertOne({
+      newCol: "new"
+    })
+  );
+  const rowOne = await query(
+    AddCol.select({ id: AddCol.id, newCol: AddCol.newCol }).first()
+  );
+  assert.equal(rowOne, { id: 1, newCol: "new" });
+});
+test.run();

package/dist/test/TestSubQueries.js

@@ -0,0 +1,79 @@
+// test/TestSubQueries.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, create, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+test("IncludeMany", async () => {
+  const query = await connect();
+  const Role = table({
+    name: "Role",
+    columns: {
+      id: column.integer().primaryKey(),
+      name: column.string()
+    }
+  });
+  const User = table({
+    name: "User",
+    columns: {
+      id: column.integer().primaryKey(),
+      roles: column.array()
+    }
+  });
+  const Entry = table({
+    name: "Entry",
+    columns: {
+      id: column.integer().primaryKey()
+    }
+  });
+  const Language = table({
+    name: "Language",
+    columns: {
+      id: column.integer().primaryKey(),
+      entry: column.integer()
+    }
+  });
+  const Version = table({
+    name: "Version",
+    columns: {
+      id: column.integer().primaryKey(),
+      language: column.integer()
+    }
+  });
+  await query(create(Role, User, Entry, Language, Version));
+  const role1 = await query(Role.insertOne({ name: "role1" }));
+  const role2 = await query(Role.insertOne({ name: "role2" }));
+  const user = await query(User.insertOne({ roles: [role1.id, role2.id] }));
+  const UserAlias = User.as("user1");
+  const RoleAlias = Role.as("role");
+  const bundled = await query(
+    UserAlias.first().select({
+      ...UserAlias,
+      roles: RoleAlias.select({
+        name: RoleAlias.name
+      }).orderBy(RoleAlias.name.asc()).where(RoleAlias.id.isIn(UserAlias.roles))
+    })
+  );
+  assert.equal(bundled.roles, [{ name: "role1" }, { name: "role2" }]);
+  const entry = await query(Entry.insertOne({}));
+  const language = await query(Language.insertOne({ entry: entry.id }));
+  const version1 = await query(
+    Version.insertOne({
+      language: language.id
+    })
+  );
+  const version2 = await query(
+    Version.insertOne({
+      language: language.id
+    })
+  );
+  const languages = Language.where(Language.entry.is(Entry.id)).select({
+    ...Language,
+    versions: Version.where(Version.language.is(Language.id))
+  });
+  const page = await query(Entry.select({ ...Entry, languages }).first());
+  assert.equal(page, {
+    ...entry,
+    languages: [{ ...language, versions: [version1, version2] }]
+  });
+});
+test.run();

package/dist/test/TestTransaction.js

@@ -0,0 +1,54 @@
+// test/TestTransaction.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+var User = table({
+  name: "User",
+  columns: {
+    id: column.integer().primaryKey(),
+    name: column.string()
+  }
+});
+test("Transaction", async () => {
+  const query = await connect();
+  const [_, bob] = await Promise.all([
+    query.transaction(async function(query2) {
+      await query2(User.createTable());
+      await query2(User.insertOne({ name: "Alice" }));
+      await query2(User.insertOne({ name: "Bob" }));
+    }),
+    query(User.first().where(User.name.is("Bob")))
+  ]);
+  assert.equal(bob?.name, "Bob");
+});
+test("Rollback", async () => {
+  const query = await connect();
+  await query(User.createTable());
+  await query.transaction(async function(query2) {
+    await query2(User.insertOne({ name: "Bob" }));
+    throw new Error("Rollback");
+  }).catch(() => {
+  });
+  const bob = await query(User.first().where(User.name.is("Bob")));
+  assert.is(bob, void 0);
+});
+test("Savepoints", async () => {
+  const query = await connect();
+  await query(User.createTable());
+  await query.transaction(async function(query2) {
+    await query2(User.insertOne({ name: "Bob" }));
+    await query2.transaction(async function(query3) {
+      await query3(User.insertOne({ name: "Ted" }));
+      throw new Error("Rollback");
+    }).catch(() => {
+    });
+    await query2(User.insertOne({ name: "Alice" }));
+  });
+  const users = await query(User);
+  assert.equal(users, [
+    { id: 1, name: "Bob" },
+    { id: 2, name: "Alice" }
+  ]);
+});
+test.run();

package/dist/test/TestUpdate.js

@@ -0,0 +1,95 @@
+// test/TestUpdate.ts
+import { test } from "uvu";
+import * as assert from "uvu/assert";
+import { column, table } from "../src/index.js";
+import { connect } from "./DbSuite.js";
+var User = table({
+  name: "user",
+  columns: {
+    id: column.integer().primaryKey(),
+    name: column.object(),
+    email: column.string().nullable(),
+    roles: column.array().nullable()
+  }
+});
+test("Update", async () => {
+  const query = await connect();
+  await query(User.createTable());
+  const user = await query(
+    User.insertOne({
+      name: {
+        given: "abc",
+        last: "test"
+      }
+    })
+  );
+  const res = await query(
+    User.set({
+      email: "test"
+    }).where(User.id.is(user.id))
+  );
+  assert.is(res.rowsAffected, 1);
+  assert.is((await query(User.first())).email, "test");
+  const res2 = await query(
+    User.set({
+      email: User.email.concat("@example.com")
+    }).where(User.id.is(user.id))
+  );
+  assert.is(res2.rowsAffected, 1);
+  assert.is((await query(User.first())).email, "test@example.com");
+  const res3 = await query(
+    User.set({
+      name: {
+        given: "def",
+        last: "okay"
+      }
+    }).where(User.id.is(user.id))
+  );
+  assert.is(res3.rowsAffected, 1);
+  assert.is((await query(User.first())).name.given, "def");
+});
+test("Update object", async () => {
+  const query = await connect();
+  await query(User.createTable());
+  const user = await query(
+    User.insertOne({
+      name: {
+        given: "abc",
+        last: "test"
+      }
+    })
+  );
+  const res = await query(
+    User.set({
+      name: {
+        given: "123",
+        last: "456"
+      }
+    }).where(User.id.is(user.id))
+  );
+  assert.is(res.rowsAffected, 1);
+  const user2 = await query(User.where(User.id.is(user.id)).first());
+  assert.is(user2.name.given, "123");
+  assert.is(user2.name.last, "456");
+});
+test("Update array", async () => {
+  const query = await connect();
+  await query(User.createTable());
+  const user = await query(
+    User.insertOne({
+      name: {
+        given: "abc",
+        last: "test"
+      }
+    })
+  );
+  const res = await query(
+    User.set({
+      roles: ["a", "b"]
+    }).where(User.id.is(user.id))
+  );
+  assert.is(res.rowsAffected, 1);
+  const user2 = await query(User.first().where(User.id.is(user.id)));
+  assert.equal(user2.roles, ["a", "b"]);
+});
+test.run();

package/dist/test/index.js

@@ -0,0 +1,14 @@
+// test/index.ts
+import sade from "sade";
+import { parse } from "uvu/parse";
+import { run } from "uvu/run";
+sade("test [pattern]", true).option("--driver", "Pick driver").action((pattern, opts) => {
+  process.env.TEST_DRIVER = opts.driver || "better-sqlite3";
+  parse("test", "Test*").then(
+    ({ suites }) => run(
+      suites.filter(
+        ({ name }) => pattern ? name.toLowerCase().includes(pattern) : name.startsWith("Test")
+      )
+    )
+  );
+}).parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",

package/dist/lib/Column.d.ts

@@ -1,57 +0,0 @@
-import { EV, Expr, ExprData } from './Expr';
-export declare enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-interface PartialColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: ExprData;
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-    references?: ExprData;
-}
-export interface ColumnData extends PartialColumnData {
-    type: ColumnType;
-    name: string;
-}
-export declare class Column<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.IsOptional<T>>;
-    primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
-    unique(): Column<T>;
-    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
-}
-export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
-};
-export declare namespace Column {
-    const isOptional: unique symbol;
-    type IsOptional<T> = {
-        [isOptional]: true;
-        __t: T;
-    };
-    const isPrimary: unique symbol;
-    type IsPrimary<T, K> = {
-        [isPrimary]: K;
-        __t: T;
-    };
-}
-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[]>;
-};
-export {};

package/dist/lib/Cursor.d.ts

@@ -1,85 +0,0 @@
-import { Driver } from './Driver';
-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> {
-    [Selection.__cursorType](): T;
-    constructor(query: Query<T>);
-    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    query(): Query<T>;
-    on(driver: Driver.Sync): T;
-    on(driver: Driver.Async): Promise<T>;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Delete extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-        where(...where: Array<EV<boolean>>): Delete;
-        take(limit: number | undefined): Delete;
-        skip(offset: number | undefined): Delete;
-    }
-    class Update<T> extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-        where(...where: Array<EV<boolean>>): Update<T>;
-        take(limit: number | undefined): Update<T>;
-        skip(offset: number | undefined): 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 CreateTable 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 Cursor<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<Expr<any> | OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        sure(): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        take(limit: number | undefined): SelectMultiple<T>;
-        skip(offset: number | undefined): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Cursor<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>;
-        take(limit: number | undefined): SelectSingle<T>;
-        skip(offset: number | undefined): SelectSingle<T>;
-        all(): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-}