rado 0.3.4 → 0.3.6

package/dist/src/sqlite/SqliteSchema.js

@@ -1,47 +0,0 @@
-// src/sqlite/SqliteSchema.ts
-import { Cursor } from "../lib/Cursor.js";
-import { Statement } from "../lib/Statement.js";
-import { SqliteFormatter } from "./SqliteFormatter.js";
-var SqliteSchema;
-((SqliteSchema2) => {
-  const formatter = new SqliteFormatter();
-  function tableData(tableName) {
-    return Cursor.all`select * from pragma_table_info(${tableName}) order by cid`;
-  }
-  SqliteSchema2.tableData = tableData;
-  function indexData(tableName) {
-    return Cursor.all`select * from sqlite_master where type='index' and tbl_name=${tableName}`;
-  }
-  SqliteSchema2.indexData = indexData;
-  function createInstructions(columnData, indexData2) {
-    if (columnData.length === 0 && indexData2.length === 0)
-      return void 0;
-    const columns = columnData.map(columnInstruction);
-    const indexes = indexData2.map(indexInstruction).filter((row) => row[1]);
-    return {
-      columns: Object.fromEntries(columns),
-      indexes: Object.fromEntries(indexes)
-    };
-  }
-  SqliteSchema2.createInstructions = createInstructions;
-  function columnInstruction(column) {
-    const stmt = new Statement(formatter);
-    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.sql];
-  }
-  SqliteSchema2.columnInstruction = columnInstruction;
-  function indexInstruction(index) {
-    return [index.name, index.sql];
-  }
-  SqliteSchema2.indexInstruction = indexInstruction;
-})(SqliteSchema || (SqliteSchema = {}));
-export {
-  SqliteSchema
-};

package/dist/src/sqlite.js

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

package/dist/test/DbSuite.js

@@ -1,28 +0,0 @@
-// test/DbSuite.ts
-async function connect() {
-  switch (process.env.TEST_DRIVER) {
-    case "better-sqlite3": {
-      const { default: BetterSqlite3Database } = await import("better-sqlite3");
-      const { connect: createConnection } = await import("../src/driver/better-sqlite3.js");
-      return createConnection(new BetterSqlite3Database(":memory:")).toAsync();
-    }
-    case "sql.js": {
-      const { default: init } = await import("sql.js");
-      const { Database } = await init();
-      const { connect: createConnection } = await import("../src/driver/sql.js.js");
-      return createConnection(new Database()).toAsync();
-    }
-    case "sqlite3": {
-      const {
-        default: { Database }
-      } = await import("sqlite3");
-      const { connect: createConnection } = await import("../src/driver/sqlite3.js");
-      return createConnection(new Database(":memory:"));
-    }
-    default:
-      throw new Error(`Unknown driver ${process.env.TEST_DRIVER}`);
-  }
-}
-export {
-  connect
-};

package/dist/test/TSTestTypes.js

@@ -1,6 +0,0 @@
-// test/TSTestTypes.ts
-var test = void 0;
-var shouldBeExpr = test.location;
-var shouldBeExprNumber = test.location.lat;
-var test2 = void 0;
-var typeAccessible = test2.item.type.is("test");

package/dist/test/TestBasic.js

@@ -1,172 +0,0 @@
-// test/TestBasic.ts
-import { test } from "uvu";
-import * as assert from "uvu/assert";
-import {
-  Expr,
-  column,
-  create,
-  insertInto,
-  selectFirst,
-  table
-} from "../src/index.js";
-import { connect } from "./DbSuite.js";
-test("basic", async () => {
-  const query = await connect();
-  const Node = table({
-    name: "node",
-    columns: {
-      id: column.integer().primaryKey(),
-      index: column.number()
-    }
-  });
-  await query(create(Node));
-  const amount = 10;
-  const objects = Array.from({ length: amount }).map((_, index) => ({ index }));
-  assert.equal(objects.length, amount);
-  await query(Node.insertAll(objects));
-  assert.equal((await query(Node)).length, amount);
-  const stored = await query(Node);
-  const id = stored[amount - 1].id;
-  assert.equal(
-    (await query(
-      Node.sure().where(
-        Node.index.greaterOrEqual(amount - 1),
-        Node.index.less(amount)
-      )
-    )).id,
-    id
-  );
-});
-test("filters", async () => {
-  const query = await connect();
-  const Test = table({
-    name: "test",
-    columns: {
-      id: column.integer().primaryKey(),
-      prop: column.number()
-    }
-  });
-  await query(create(Test));
-  const a = { prop: 10 };
-  const b = { prop: 20 };
-  await query(Test.insertAll([a, b]));
-  const gt10 = await query.get(Test.where(Test.prop.greater(10)));
-  assert.equal(gt10.prop, 20);
-});
-test("select", async () => {
-  const query = await connect();
-  const Test = table({
-    name: "test",
-    columns: {
-      id: column.integer().primaryKey(),
-      propA: column.number(),
-      propB: column.number()
-    }
-  });
-  await query(create(Test));
-  const a = { propA: 10, propB: 5 };
-  const b = { propA: 20, propB: 5 };
-  await query(Test.insertAll([a, b]));
-  const res = await query(Test.select({ a: Test.propA, b: Test.propB }));
-  assert.equal(res, [
-    { a: 10, b: 5 },
-    { a: 20, b: 5 }
-  ]);
-  const res2 = await query(
-    Test.select({
-      ...Test,
-      testProp: Expr.value(123)
-    }).sure()
-  );
-  assert.is(res2.testProp, 123);
-  const res3 = await query(Test.sure().select(Expr.value("test")));
-  assert.is(res3, "test");
-  const res4 = await query(Test.sure().select(Expr.value(true)));
-  assert.is(res4, true);
-});
-test("update", async () => {
-  const query = await connect();
-  const Test = table({
-    name: "test",
-    columns: {
-      id: column.integer().primaryKey(),
-      propA: column.number(),
-      propB: column.number()
-    }
-  });
-  Test.id;
-  await query(Test.createTable());
-  const a = { propA: 10, propB: 5 };
-  const b = { propA: 20, propB: 5 };
-  await query(Test.insertAll([a, b]));
-  await query(Test.set({ propA: 15 }).where(Test.propA.is(10)));
-  assert.ok(await query(Test.sure().where(Test.propA.is(15))));
-});
-test("json", async () => {
-  const query = await connect();
-  const Test = table({
-    name: "test",
-    columns: {
-      id: column.integer().primaryKey(),
-      prop: column.number(),
-      propB: column.number()
-    }
-  });
-  await query(create(Test));
-  const a = { prop: 10, propB: 5 };
-  const b = { prop: 20, propB: 5 };
-  await query(insertInto(Test).values(a, b));
-  const q = Test.sure().select({
-    fieldA: Expr.value(12),
-    fieldB: Test.propB
-  }).where(Test.prop.is(10));
-  const res1 = await query(q);
-  assert.is(res1.fieldA, 12);
-  assert.is(res1.fieldB, 5);
-});
-test("each", async () => {
-  const query = await connect();
-  const a = {
-    refs: [
-      { id: 1, type: "entry" },
-      { id: 0, type: "nonsense" },
-      { id: 2, type: "entry" }
-    ]
-  };
-  const Test = table({
-    name: "test",
-    columns: {
-      id: column.integer().primaryKey(),
-      refs: column.array()
-    }
-  });
-  const Entry = table({
-    name: "Entry",
-    columns: {
-      id: column.integer().primaryKey(),
-      title: column.string()
-    }
-  });
-  await query(create(Test, Entry));
-  await query(insertInto(Test).values(a));
-  const res = await query(selectFirst(Test).select({ refs: Test.refs }));
-  assert.equal(res, a);
-  const b = { title: "Entry B" };
-  const c = { title: "Entry C" };
-  await query(create(Entry));
-  await query(Entry.insertAll([b, c]));
-  const Link = Entry.as("Link");
-  const tests = Test.select({
-    links: Test.refs.filter((ref) => {
-      return ref.type.is("entry");
-    }).map((ref) => {
-      return Link.fetch(ref.id).select({ id: Link.id, title: Link.title });
-    })
-  }).sure();
-  const res2 = await query(tests);
-  assert.equal(res2.links, [
-    { id: 1, title: "Entry B" },
-    { id: 2, title: "Entry C" }
-  ]);
-});
-test.run();

package/dist/test/TestExtend.js

@@ -1,68 +0,0 @@
-// test/TestExtend.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 UserTable = table({
-  name: "user",
-  columns: {
-    id: column.integer().primaryKey(),
-    firstName: column.string(),
-    lastName: column.string()
-  }
-});
-var User = table.extend(UserTable, {
-  name() {
-    return this.firstName.concat(" ").concat(this.lastName);
-  },
-  roles() {
-    return Role.innerJoin(UserRoles, Role.id.is(UserRoles.roleId)).innerJoin(
-      this,
-      UserRoles.userId.is(this.id)
-    );
-  }
-});
-var Role = table({
-  name: "role",
-  columns: {
-    id: column.integer().primaryKey(),
-    name: column.string()
-  }
-});
-var UserRoles = table({
-  name: "user_roles",
-  columns: {
-    userId: column.integer().references(UserTable.id),
-    roleId: column.integer().references(Role.id)
-  }
-});
-test("Extend", async () => {
-  const query = await connect();
-  await query(create(Role, User, UserRoles));
-  const user1 = await query(
-    User.insertOne({
-      firstName: "a",
-      lastName: "b"
-    })
-  );
-  const role1 = await query(Role.insertOne({ name: "role1" }));
-  const role2 = await query(Role.insertOne({ name: "role2" }));
-  await query(
-    UserRoles.insertAll([
-      { userId: user1.id, roleId: role1.id },
-      { userId: user1.id, roleId: role2.id }
-    ])
-  );
-  const { Aliased } = User.alias();
-  const user = await query(
-    Aliased.first().select({
-      name: Aliased.name(),
-      roles: Aliased.roles()
-    })
-  );
-  assert.equal(user, {
-    name: "a b",
-    roles: [role1, role2]
-  });
-});
-test.run();

package/dist/test/TestFts5.js

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

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

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

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

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

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

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

@@ -1,79 +0,0 @@
-// 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();