rado 0.3.2 → 0.3.4

package/dist/src/lib/Statement.js

@@ -0,0 +1,103 @@
+// src/lib/Statement.ts
+import { ParamData, ParamType } from "./Param.js";
+var SEPARATE = ", ";
+var WHITESPACE = " ";
+var NEWLINE = "\n";
+var INSERT_PARAM = "?";
+var Statement = class {
+  constructor(sanitizer, sql = "", paramData = []) {
+    this.sanitizer = sanitizer;
+    this.sql = sql;
+    this.paramData = paramData;
+  }
+  currentIndent = "";
+  space() {
+    if (this.sql === "")
+      return this;
+    return this.raw(WHITESPACE);
+  }
+  add(addition) {
+    if (!addition)
+      return this;
+    return this.space().raw(addition);
+  }
+  addLine(addition) {
+    if (!addition)
+      return this;
+    return this.newline().add(addition);
+  }
+  indent() {
+    this.currentIndent = this.currentIndent + "  ";
+    return this;
+  }
+  dedent() {
+    this.currentIndent = this.currentIndent.slice(0, -2);
+    return this;
+  }
+  newline() {
+    return this.raw(NEWLINE + this.currentIndent);
+  }
+  identifier(name) {
+    return this.raw(this.sanitizer.escapeIdentifier(name));
+  }
+  addIdentifier(name) {
+    return this.space().identifier(name);
+  }
+  value(value) {
+    this.paramData.push(ParamData.Value(value));
+    return this.raw(INSERT_PARAM);
+  }
+  addValue(value) {
+    return this.space().value(value);
+  }
+  param(name) {
+    this.paramData.push(ParamData.Named(name));
+    return this.raw(INSERT_PARAM);
+  }
+  addParam(name) {
+    return this.space().param(name);
+  }
+  raw(query) {
+    if (!query)
+      return this;
+    this.sql += query;
+    return this;
+  }
+  openParenthesis() {
+    return this.raw("(").indent().newline();
+  }
+  closeParenthesis() {
+    return this.dedent().newline().raw(")");
+  }
+  *call(parts, separator = SEPARATE) {
+    this.openParenthesis();
+    yield* this.separate(parts, separator);
+    this.closeParenthesis();
+  }
+  *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.sql === "";
+  }
+  params(input) {
+    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(param.value);
+    });
+  }
+  toString() {
+    return this.sql;
+  }
+};
+export {
+  Statement
+};

package/dist/{lib → src/lib}/Table.js

@@ -59,7 +59,7 @@ var Table = class extends Cursor.SelectMultiple {
     return new Cursor.Delete(Query.Delete({ table: this.schema() }));
   }
   createTable() {
-    return new Cursor.CreateTable(this.schema());
+    return new Cursor.Create(this.schema());
   }
   as(alias) {
     return new Table({ ...this.schema(), alias });

package/dist/{lib → src/lib}/Target.js

@@ -1,21 +1,16 @@
 // src/lib/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
-  TargetType2["Expr"] = "Expr";
-  TargetType2["Query"] = "Query";
+  TargetType2["Each"] = "Each";
   TargetType2["Table"] = "Table";
   TargetType2["Join"] = "Join";
   return TargetType2;
 })(TargetType || {});
 var Target;
 ((Target2) => {
-  function Expr(expr, alias) {
-    return { type: "Expr" /* Expr */, expr, alias };
+  function Each(expr, alias) {
+    return { type: "Each" /* Each */, expr, alias };
   }
-  Target2.Expr = Expr;
-  function Query(query, alias) {
-    return { type: "Query" /* Query */, query, alias };
-  }
-  Target2.Query = Query;
+  Target2.Each = Each;
   function Table(table) {
     return { type: "Table" /* Table */, table };
   }

package/dist/src/sqlite/SqliteFormatter.js

@@ -0,0 +1,67 @@
+// src/sqlite/SqliteFormatter.ts
+import { ExprType } from "../lib/Expr.js";
+import { Formatter } from "../lib/Formatter.js";
+import { TargetType } from "../lib/Target.js";
+var BACKTICK = "`";
+var ESCAPE_BACKTICK = "``";
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_BACKTICK = /`/g;
+var MATCH_SINGLE_QUOTE = /'/g;
+var SqliteFormatter = class extends Formatter {
+  formatParamValue(paramValue) {
+    if (paramValue === null || paramValue === void 0)
+      return null;
+    if (typeof paramValue === "boolean")
+      return paramValue ? 1 : 0;
+    if (typeof paramValue === "number")
+      return paramValue;
+    if (typeof paramValue === "string")
+      return paramValue;
+    return JSON.stringify(paramValue);
+  }
+  escapeValue(value) {
+    if (value === null || value === void 0)
+      return "NULL";
+    if (typeof value === "boolean")
+      return value ? "1" : "0";
+    if (typeof value === "number")
+      return String(value);
+    if (typeof value === "string")
+      return this.escapeString(value);
+    return "json(" + this.escapeString(JSON.stringify(value)) + ")";
+  }
+  escapeIdentifier(input) {
+    return BACKTICK + input.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
+  }
+  escapeString(input) {
+    return SINGLE_QUOTE + input.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
+  }
+  formatAccess(ctx, mkSubject, field) {
+    const { stmt, formatAsJson } = ctx;
+    mkSubject();
+    stmt.raw(formatAsJson ? "->" : "->>");
+    return this.formatString(ctx, `$.${field}`);
+  }
+  formatExpr(ctx, expr) {
+    const { stmt } = ctx;
+    switch (expr.type) {
+      case ExprType.Call:
+        if (expr.method === "match") {
+          const [from, query] = expr.params;
+          if (from.type !== ExprType.Row)
+            throw new Error("not implemented");
+          if (from.target.type !== TargetType.Table)
+            throw new Error("not implemented");
+          stmt.identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ");
+          this.formatExprValue(ctx, query);
+          return stmt;
+        }
+      default:
+        return super.formatExpr(ctx, expr);
+    }
+  }
+};
+export {
+  SqliteFormatter
+};

package/dist/src/sqlite/SqliteFunctions.js

@@ -0,0 +1,146 @@
+// src/sqlite/SqliteFunctions.ts
+import { Functions } from "../lib/Functions.js";
+var SqliteFunctions = Functions;
+var {
+  count,
+  iif,
+  exists,
+  match,
+  cast,
+  abs,
+  changes,
+  char,
+  coalesce,
+  ifnull,
+  instr,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  lower,
+  ltrim,
+  max,
+  min,
+  nullif,
+  prnumberf,
+  quote,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  soundex,
+  sqlite_version,
+  substr,
+  total_changes,
+  trim,
+  unicode,
+  unlikely,
+  upper,
+  avg,
+  group_concat,
+  sum,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  ceil,
+  cos,
+  cosh,
+  degrees,
+  exp,
+  floor,
+  ln,
+  log,
+  log2,
+  mod,
+  pi,
+  pow,
+  radians,
+  sin,
+  sinh,
+  sqrt,
+  tan,
+  tanh,
+  trunc,
+  date,
+  time,
+  datetime,
+  julianday,
+  strftime
+} = SqliteFunctions;
+export {
+  SqliteFunctions,
+  abs,
+  acos,
+  acosh,
+  asin,
+  asinh,
+  atan,
+  atan2,
+  atanh,
+  avg,
+  cast,
+  ceil,
+  changes,
+  char,
+  coalesce,
+  cos,
+  cosh,
+  count,
+  date,
+  datetime,
+  degrees,
+  exists,
+  exp,
+  floor,
+  group_concat,
+  ifnull,
+  iif,
+  instr,
+  julianday,
+  last_insert_rowid,
+  length,
+  likelihood,
+  likely,
+  ln,
+  log,
+  log2,
+  lower,
+  ltrim,
+  match,
+  max,
+  min,
+  mod,
+  nullif,
+  pi,
+  pow,
+  prnumberf,
+  quote,
+  radians,
+  random,
+  replace,
+  round,
+  rtrim,
+  sign,
+  sin,
+  sinh,
+  soundex,
+  sqlite_version,
+  sqrt,
+  strftime,
+  substr,
+  sum,
+  tan,
+  tanh,
+  time,
+  total_changes,
+  trim,
+  trunc,
+  unicode,
+  unlikely,
+  upper
+};

package/dist/src/sqlite/SqliteSchema.js

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

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

package/dist/test/DbSuite.js

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

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

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

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