rado 0.3.1 → 0.3.2

package/dist/lib/Table.js

@@ -0,0 +1,130 @@
+// src/lib/Table.ts
+import { Cursor } from "./Cursor.js";
+import { Expr, ExprData } from "./Expr.js";
+import { Query } from "./Query.js";
+import { Selection } from "./Selection.js";
+import { Target } from "./Target.js";
+var Table = class extends Cursor.SelectMultiple {
+  [Selection.__tableType]() {
+    throw "assert";
+  }
+  constructor(schema) {
+    super(
+      Query.Select({
+        from: Target.Table(schema),
+        selection: ExprData.Row(Target.Table(schema))
+      })
+    );
+    Object.defineProperty(this, "schema", {
+      enumerable: false,
+      value: () => schema
+    });
+    if (schema.columns)
+      for (const column of Object.keys(schema.columns)) {
+        Object.defineProperty(this, column, {
+          enumerable: true,
+          get: () => this.get(column)
+        });
+      }
+    return new Proxy(this, {
+      get(target, key) {
+        return key in target ? target[key] : target.get(key);
+      }
+    });
+  }
+  fetch(id) {
+    return this.where(this.get("id").is(id)).first();
+  }
+  insertOne(record) {
+    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);
+  }
+  set(data) {
+    return new Cursor.Update(
+      Query.Update({
+        table: this.schema()
+      })
+    ).set(data);
+  }
+  delete() {
+    return new Cursor.Delete(Query.Delete({ table: this.schema() }));
+  }
+  createTable() {
+    return new Cursor.CreateTable(this.schema());
+  }
+  as(alias) {
+    return new Table({ ...this.schema(), alias });
+  }
+  alias() {
+    return new Proxy(
+      {},
+      {
+        get: (_, key) => {
+          return this.as(key);
+        }
+      }
+    );
+  }
+  get(name) {
+    return new Expr(ExprData.Field(this.toExpr().expr, name));
+  }
+  toExpr() {
+    return new Expr(
+      ExprData.Row(Target.Table(this.schema()))
+    );
+  }
+  schema() {
+    throw new Error("Not implemented");
+  }
+};
+function table(options) {
+  const schema = {
+    ...options,
+    columns: Object.fromEntries(
+      Object.entries(options.columns).map(([key, column]) => {
+        const { data } = column;
+        return [key, { ...data, name: data.name || key }];
+      })
+    ),
+    indexes: {}
+  };
+  const indexes = Object.fromEntries(
+    Object.entries(
+      options.indexes ? options.indexes.call(
+        new Expr(ExprData.Row(Target.Table(schema)))
+      ) : {}
+    ).map(([key, index]) => {
+      const indexName = `${schema.name}.${key}`;
+      return [indexName, { name: indexName, ...index.data }];
+    })
+  );
+  return new Table({
+    ...schema,
+    indexes
+  });
+}
+((table2) => {
+  function extend(target, extensions) {
+    return new Proxy(target, {
+      get(target2, key) {
+        if (key === "as")
+          return (...args) => extend(target2.as(...args), extensions);
+        return key in extensions ? extensions[key].bind(target2) : target2[key];
+      }
+    });
+  }
+  table2.extend = extend;
+})(table || (table = {}));
+export {
+  Table,
+  table
+};

package/dist/lib/Target.d.ts

@@ -0,0 +1,38 @@
+import { ExprData } from './Expr';
+import { Query as QueryData } from './Query';
+import { Schema } from './Schema';
+export declare enum TargetType {
+    Expr = "Expr",
+    Query = "Query",
+    Table = "Table",
+    Join = "Join"
+}
+export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
+export declare namespace Target {
+    interface Expr {
+        type: TargetType.Expr;
+        expr: ExprData;
+        alias?: string;
+    }
+    function Expr(expr: ExprData, alias?: string): Expr;
+    interface Query {
+        type: TargetType.Query;
+        query: QueryData;
+        alias?: string;
+    }
+    function Query(query: QueryData, alias?: string): Query;
+    interface Table {
+        type: TargetType.Table;
+        table: Schema;
+    }
+    function Table(table: Schema): Table;
+    interface Join {
+        type: TargetType.Join;
+        left: Target;
+        right: Target;
+        joinType: 'left' | 'inner';
+        on: ExprData;
+    }
+    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
+    function source(from: Target): Schema | undefined;
+}

package/dist/lib/Target.js

@@ -0,0 +1,42 @@
+// src/lib/Target.ts
+var TargetType = /* @__PURE__ */ ((TargetType2) => {
+  TargetType2["Expr"] = "Expr";
+  TargetType2["Query"] = "Query";
+  TargetType2["Table"] = "Table";
+  TargetType2["Join"] = "Join";
+  return TargetType2;
+})(TargetType || {});
+var Target;
+((Target2) => {
+  function Expr(expr, alias) {
+    return { type: "Expr" /* Expr */, expr, alias };
+  }
+  Target2.Expr = Expr;
+  function Query(query, alias) {
+    return { type: "Query" /* Query */, query, alias };
+  }
+  Target2.Query = Query;
+  function Table(table) {
+    return { type: "Table" /* Table */, table };
+  }
+  Target2.Table = Table;
+  function Join(left, right, joinType, on) {
+    return { type: "Join" /* Join */, left, right, joinType, on };
+  }
+  Target2.Join = Join;
+  function source(from) {
+    switch (from.type) {
+      case "Table" /* Table */:
+        return from.table;
+      case "Join" /* Join */:
+        return source(from.left);
+      default:
+        return void 0;
+    }
+  }
+  Target2.source = source;
+})(Target || (Target = {}));
+export {
+  Target,
+  TargetType
+};

package/dist/lib/Update.d.ts

@@ -0,0 +1,4 @@
+import type { EV } from './Expr';
+export type Update<Row> = Partial<{
+    [K in keyof Row]: EV<Row[K]>;
+}>;

package/package.json

@@ -1,74 +1,74 @@
-{
-  "name": "rado",
-  "version": "0.3.1",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./*": "./dist/*.js",
-    "./driver/bun:sqlite": "./dist/driver/bun-sqlite.js"
-  },
-  "typesVersions": {
-    "*": {
-      "driver/*": [
-        "dist/driver/*.d.ts"
-      ],
-      "lib/*": [
-        "dist/lib/*.d.ts"
-      ],
-      "driver/bun:sqlite": [
-        "dist/driver/bun-sqlite.d.ts"
-      ],
-      "define/*": [
-        "dist/define/*.d.ts"
-      ],
-      "sqlite/*": [
-        "dist/sqlite/*.d.ts"
-      ],
-      "sqlite": [
-        "dist/sqlite.d.ts"
-      ],
-      "util/*": [
-        "dist/util/*.d.ts"
-      ]
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "sideEffects": false,
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsx build.ts",
-    "test": "tsx test",
-    "test:bun": "bun test/index.ts --driver=bun:sqlite",
-    "profile": "cross-env PROFILE=true tsx build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
-    "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",
-    "bun-types": "^0.5.0",
-    "cross-env": "^7.0.3",
-    "esbuild": "^0.17.10",
-    "glob": "^8.0.3",
-    "rimraf": "^4.1.2",
-    "sade": "^1.8.1",
-    "speedscope": "^1.15.0",
-    "sql.js": "^1.8.0",
-    "sqlite3": "^5.1.6",
-    "tsx": "^3.12.3",
-    "typescript": "beta",
-    "uvu": "^0.5.6"
-  },
-  "volta": {
-    "node": "18.12.1"
-  },
-  "packageManager": "yarn@3.3.1",
-  "resolutions": {
-    "esbuild": "0.17.10"
-  }
-}
+{
+  "name": "rado",
+  "version": "0.3.2",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js",
+    "./driver/bun:sqlite": "./dist/driver/bun-sqlite.js"
+  },
+  "typesVersions": {
+    "*": {
+      "driver/*": [
+        "dist/driver/*.d.ts"
+      ],
+      "lib/*": [
+        "dist/lib/*.d.ts"
+      ],
+      "driver/bun:sqlite": [
+        "dist/driver/bun-sqlite.d.ts"
+      ],
+      "define/*": [
+        "dist/define/*.d.ts"
+      ],
+      "sqlite/*": [
+        "dist/sqlite/*.d.ts"
+      ],
+      "sqlite": [
+        "dist/sqlite.d.ts"
+      ],
+      "util/*": [
+        "dist/util/*.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsx build.ts",
+    "test": "tsx test",
+    "test:bun": "bun test/index.ts --driver=bun:sqlite",
+    "profile": "cross-env PROFILE=true tsx build.ts && cd bin && (rimraf CPU*.cpuprofile || true) && node --cpu-prof --cpu-prof-interval=100 test && speedscope CPU*.cpuprofile",
+    "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",
+    "bun-types": "^0.5.0",
+    "cross-env": "^7.0.3",
+    "esbuild": "^0.17.10",
+    "glob": "^8.0.3",
+    "rimraf": "^4.1.2",
+    "sade": "^1.8.1",
+    "speedscope": "^1.15.0",
+    "sql.js": "^1.8.0",
+    "sqlite3": "^5.1.6",
+    "tsx": "^3.12.3",
+    "typescript": "beta",
+    "uvu": "^0.5.6"
+  },
+  "volta": {
+    "node": "18.12.1"
+  },
+  "packageManager": "yarn@3.3.1",
+  "resolutions": {
+    "esbuild": "0.17.10"
+  }
+}