@primate/postgresql 0.1.2 → 0.2.0

package/lib/private/ColumnTypes.d.ts

@@ -0,0 +1,23 @@
+import type TypedArray from "@rcompat/type/TypedArray";
+type Param = Array<unknown> | bigint | boolean | Date | null | number | object | string | TypedArray;
+type Validate<T extends {
+    [K in keyof T]: Param;
+}> = T;
+type ColumnTypes = Validate<{
+    BIGINT: string;
+    BOOLEAN: boolean;
+    BYTEA: TypedArray;
+    FLOAT8: number;
+    INTEGER: number;
+    "NUMERIC(20, 0)": string;
+    "NUMERIC(39, 0)": string;
+    REAL: number;
+    "SERIAL PRIMARY KEY": number;
+    SMALLINT: number;
+    TEXT: string;
+    TIME: string;
+    TIMESTAMP: Date;
+    UUID: string;
+}>;
+export type { ColumnTypes as default };
+//# sourceMappingURL=ColumnTypes.d.ts.map

package/lib/private/ColumnTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ColumnTypes.js.map

package/lib/private/Database.d.ts

@@ -0,0 +1,46 @@
+import Database from "@primate/core/Database";
+import type As from "@primate/core/database/As";
+import type DataDict from "@primate/core/database/DataDict";
+import type TypeMap from "@primate/core/database/TypeMap";
+import type Dict from "@rcompat/type/Dict";
+import type StoreSchema from "pema/StoreSchema";
+declare const schema: import("pema").ObjectType<{
+    database: import("pema/string").StringType;
+    host: import("pema").DefaultType<import("pema/string").StringType, "localhost">;
+    password: import("pema").OptionalType<import("pema/string").StringType>;
+    port: import("pema").DefaultType<import("pema/uint").UintType<"u32">, 5432>;
+    username: import("pema").OptionalType<import("pema/string").StringType>;
+}>;
+export default class PostgreSQLDatabase extends Database {
+    #private;
+    static config: typeof schema.input;
+    constructor(config?: typeof schema.input);
+    get typemap(): TypeMap<Dict>;
+    close(): Promise<void>;
+    get schema(): {
+        create: (name: string, store: StoreSchema) => Promise<void>;
+        delete: (name: string) => Promise<void>;
+    };
+    create<O extends Dict>(as: As, args: {
+        record: DataDict;
+    }): Promise<O>;
+    read(as: As, args: {
+        count: true;
+        criteria: DataDict;
+    }): Promise<number>;
+    read(as: As, args: {
+        criteria: DataDict;
+        fields?: string[];
+        limit?: number;
+        sort?: Dict<"asc" | "desc">;
+    }): Promise<Dict[]>;
+    update(as: As, args: {
+        changes: DataDict;
+        criteria: DataDict;
+    }): Promise<any>;
+    delete(as: As, args: {
+        criteria: DataDict;
+    }): Promise<any>;
+}
+export {};
+//# sourceMappingURL=Database.d.ts.map

package/lib/private/Database.js

@@ -0,0 +1,166 @@
+import typemap from "#typemap";
+import Database from "@primate/core/Database";
+import assert from "@rcompat/assert";
+import maybe from "@rcompat/assert/maybe";
+import pema from "pema";
+import string from "pema/string";
+import uint from "pema/uint";
+import postgres from "postgres";
+const schema = pema({
+    database: string,
+    host: string.default("localhost"),
+    password: string.optional(),
+    port: uint.port().default(5432),
+    username: string.optional(),
+});
+export default class PostgreSQLDatabase extends Database {
+    static config;
+    #factory;
+    #client;
+    constructor(config) {
+        super();
+        const parsed = schema.parse(config);
+        this.#factory = () => postgres({
+            db: parsed.database,
+            host: parsed.host,
+            pass: parsed.password,
+            port: parsed.port,
+            user: parsed.username,
+        });
+    }
+    #sql() {
+        if (this.#client === undefined) {
+            this.#client = this.#factory();
+        }
+        return this.#client;
+    }
+    #join(parts, sep) {
+        const sql = this.#sql();
+        if (parts.length === 0)
+            return sql ``;
+        return parts.slice(1).reduce((acc, p) => sql `${acc}${sep}${p}`, parts[0]);
+    }
+    async #new(name, store) {
+        const sql = this.#sql();
+        const table = sql(name);
+        const body = Object.entries(store).map(([k, v]) => sql `${sql(k)} ${sql.unsafe(this.column(v.datatype))}`);
+        await sql `CREATE TABLE IF NOT EXISTS ${table}
+      (${this.#join(body, sql `, `)})`;
+    }
+    async #drop(name) {
+        const sql = this.#sql();
+        await sql `DROP TABLE IF EXISTS ${sql(name)};`;
+    }
+    get typemap() {
+        return typemap;
+    }
+    async close() {
+        await this.#sql().end();
+    }
+    get schema() {
+        return {
+            create: this.#new.bind(this),
+            delete: this.#drop.bind(this),
+        };
+    }
+    async create(as, args) {
+        const sql = this.#sql();
+        const columns = Object.keys(args.record);
+        const binds = await this.bind(as.types, args.record);
+        const [result] = await sql `INSERT INTO
+      ${sql(as.name)}
+      ${columns.length > 0
+            ? sql `(${sql(columns)}) VALUES ${sql(binds)}`
+            : sql.unsafe("DEFAULT VALUES")}
+      RETURNING id;
+    `;
+        return this.unbind(as.types, { ...args.record, id: result.id });
+    }
+    #sort(types, sort) {
+        maybe(sort).object();
+        // validate
+        this.toSort(types, sort);
+        const sql = this.#sql();
+        if (!sort)
+            return sql ``;
+        const entries = Object.entries(sort);
+        if (entries.length === 0)
+            return sql ``;
+        const items = entries.map(([field, direction]) => sql `${sql(field)} ${sql.unsafe(direction.toUpperCase())}`);
+        return sql ` ORDER BY ${this.#join(items, sql `, `)}`;
+    }
+    #select(types, fields) {
+        // validate
+        this.toSelect(types, fields);
+        const sql = this.#sql();
+        if (fields === undefined)
+            return sql.unsafe("*");
+        return sql(fields);
+    }
+    #limit(limit) {
+        maybe(limit).usize();
+        const sql = this.#sql();
+        return limit === undefined ? sql `` : sql ` LIMIT ${limit}`;
+    }
+    #where(types, criteria, nonnull) {
+        this.toWhere(types, criteria); // validate
+        const sql = this.#sql();
+        const entries = Object.entries(criteria);
+        if (entries.length === 0)
+            return sql ``;
+        const clauses = entries.map(([key, raw]) => {
+            if (raw === null)
+                return sql `${sql(key)} IS NULL`;
+            const value = nonnull[key];
+            // Handle operator objects
+            if (typeof raw === "object") {
+                if ("$like" in raw)
+                    return sql `${sql(key)} LIKE ${value}`;
+                // if ("$gte" in raw) return sql`${sql(key)} >= ${nonnull[key]}`;
+            }
+            return sql `${sql(key)} = ${value}`;
+        });
+        return sql `WHERE ${this.#join(clauses, sql ` AND `)}`;
+    }
+    async read(as, args) {
+        const sql = this.#sql();
+        const table = sql(as.name);
+        const criteria = await this.bindCriteria(as.types, args.criteria);
+        const where = this.#where(as.types, args.criteria, criteria);
+        if (args.count === true) {
+            const [{ n }] = await sql `SELECT COUNT(*) AS n FROM ${table} ${where}`;
+            return Number(n);
+        }
+        const sort = this.#sort(as.types, args.sort);
+        const limit = this.#limit(args.limit);
+        const select = this.#select(as.types, args.fields);
+        const records = await sql `
+      SELECT ${select}
+      FROM ${table}
+      ${where}
+      ${sort}
+      ${limit}
+    `;
+        return records.map(record => this.unbind(as.types, record));
+    }
+    async update(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "update: no criteria");
+        const sql = this.#sql();
+        const table = sql(as.name);
+        const criteria = await this.bindCriteria(as.types, args.criteria);
+        const set_binds = await this.bind(as.types, args.changes);
+        const where = this.#where(as.types, args.criteria, criteria);
+        const set = sql({ ...set_binds });
+        return (await sql `UPDATE ${table} SET ${set} ${where} RETURNING 1;`).length;
+    }
+    async delete(as, args) {
+        assert(Object.keys(args.criteria).length > 0, "delete: no criteria");
+        const sql = this.#sql();
+        const criteria = await this.bindCriteria(as.types, args.criteria);
+        const where = this.#where(as.types, args.criteria, criteria);
+        const table = sql(as.name);
+        return (await sql `DELETE FROM ${table} ${where} RETURNING 1;`).length;
+    }
+    ;
+}
+//# sourceMappingURL=Database.js.map

package/lib/private/typemap.d.ts

@@ -0,0 +1,5 @@
+import type ColumnTypes from "#ColumnTypes";
+import type TypeMap from "@primate/core/database/TypeMap";
+declare const typemap: TypeMap<ColumnTypes>;
+export default typemap;
+//# sourceMappingURL=typemap.d.ts.map

package/lib/private/typemap.js

@@ -0,0 +1,105 @@
+function identity(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => value,
+    };
+}
+function number(column) {
+    return {
+        bind: value => value,
+        column,
+        unbind: value => Number(value),
+    };
+}
+const typemap = {
+    blob: {
+        async bind(value) {
+            const arrayBuffer = await value.arrayBuffer();
+            return new Uint8Array(arrayBuffer);
+        },
+        column: "BYTEA",
+        unbind(value) {
+            return new Blob([value], { type: "application/octet-stream" });
+        },
+    },
+    boolean: identity("BOOLEAN"),
+    datetime: identity("TIMESTAMP"),
+    f32: identity("REAL"),
+    f64: identity("FLOAT8"),
+    i128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "NUMERIC(39, 0)",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    i16: number("SMALLINT"),
+    i32: number("INTEGER"),
+    i64: {
+        bind(value) {
+            return String(value);
+        },
+        column: "BIGINT",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    i8: number("SMALLINT"),
+    primary: {
+        bind(value) {
+            if (typeof value === "string" && Number.isInteger(+value)) {
+                return Number(value);
+            }
+            throw new Error(`\`${value}\` is not a valid primary key value`);
+        },
+        column: "SERIAL PRIMARY KEY",
+        unbind(value) {
+            return String(value);
+        },
+    },
+    string: identity("TEXT"),
+    time: identity("TIME"),
+    u128: {
+        bind(value) {
+            return String(value);
+        },
+        column: "NUMERIC(39, 0)",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    u16: number("INTEGER"),
+    u32: {
+        bind(value) {
+            return String(value);
+        },
+        column: "BIGINT",
+        unbind(value) {
+            return Number(value);
+        },
+    },
+    u64: {
+        bind(value) {
+            return String(value);
+        },
+        column: "NUMERIC(20, 0)",
+        unbind(value) {
+            return BigInt(value);
+        },
+    },
+    u8: number("SMALLINT"),
+    url: {
+        bind(value) {
+            return value.toString();
+        },
+        column: "TEXT",
+        unbind(value) {
+            return new URL(value);
+        },
+    },
+};
+export default typemap;
+//# sourceMappingURL=typemap.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,4 @@
+import Database from "#Database";
+declare const _default: (config: typeof Database.config) => Database;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,3 @@
+import Database from "#Database";
+export default (config) => new Database(config);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,34 +1,44 @@
 {
   "name": "@primate/postgresql",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Primate PostgreSQL database",
-  "homepage": "https://primatejs.com/modules/postgresql",
-  "bugs": "https://github.com/primatejs/primate/issues",
+  "homepage": "https://primate.run/docs/database/postgresql",
+  "bugs": "https://github.com/primate-run/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**/*.js",
-    "!src/**/*.spec.js"
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "!/**/*.spec.*"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/primatejs/primate",
+    "url": "https://github.com/primate-run/primate",
     "directory": "packages/postgresql"
   },
   "dependencies": {
-    "@rcompat/invariant": "^0.5.0",
-    "@rcompat/object": "^0.5.0",
-    "postgres": "^3.4.4",
-    "@primate/core": "^0.1.4",
-    "@primate/store": "^0.25.1"
+    "@rcompat/assert": "^0.3.1",
+    "@rcompat/record": "^0.9.1",
+    "pema": "",
+    "postgres": "^3.4.7",
+    "@primate/core": "^0.2.0"
   },
   "type": "module",
   "imports": {
     "#*": {
-      "@primate/lt": "./src/private/*.js",
-      "default": "./src/private/*.js"
+      "apekit": "./src/private/*.ts",
+      "default": "./lib/private/*.js"
     }
   },
   "exports": {
-    ".": "./src/default.js"
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./lib",
+    "lint": "eslint .",
+    "test": "npm run build && npx proby"
   }
 }

package/src/default.js

@@ -1,12 +0,0 @@
-import defaults from "#defaults";
-import serve from "#serve";
-
-export default ({
-  host = defaults.host,
-  port = defaults.port,
-  database,
-  username,
-  password,
-} = {}) => ({
-  serve: serve({ host, port, database, username, password }),
-});

package/src/private/Facade.js

@@ -1,97 +0,0 @@
-import typemap from "#typemap";
-import make_sort from "@primate/store/sql/make-sort";
-import filter from "@rcompat/object/filter";
-import valmap from "@rcompat/object/valmap";
-
-const filter_null = object => filter(object, ([, value]) => value !== null);
-const filter_nulls = objects => objects.map(object => filter_null(object));
-
-export default class Connection {
-  schema = {
-    create: async (name, description) => {
-      const { connection } = this;
-      const body =
-        Object.entries(valmap(description, value => typemap(value.base)))
-          .map(([column, dataType]) => `"${column}" ${dataType}`).join(",");
-      await connection`
-        create table if not exists 
-        ${connection(name)} (${connection.unsafe(body)})
-      `;
-    },
-    delete: async name => {
-      const { connection } = this;
-      await connection`drop table if exists ${connection(name)};`;
-    },
-  };
-
-  constructor(connection) {
-    this.connection = connection;
-  }
-
-  async find(collection, criteria = {}, projection = [], options = {}) {
-    const { connection } = this;
-    const rest = make_sort(options);
-    const select = projection.length === 0 ? "*" : projection.join(", ");
-    return filter_nulls(await connection`
-      select ${connection.unsafe(select)}
-      from ${connection(collection)}
-      where ${Object.entries(criteria).reduce((acc, [key, value]) =>
-    connection`${acc} and ${connection(key)} = ${value}`, connection`true`)}
-      ${connection.unsafe(rest)}`);
-  }
-
-  async count(collection, criteria = {}) {
-    const { connection } = this;
-    const [{ count }] = await connection`
-      select count(*)
-      from ${connection(collection)}
-      where ${Object.entries(criteria).reduce((acc, [key, value]) =>
-    connection`${acc} and ${connection(key)} = ${value}`, connection`true`)}
-    `;
-    return Number(count);
-  }
-
-  async get(collection, primary, value) {
-    const { connection } = this;
-    const [result] = await connection`
-      select * 
-      from ${connection(collection)} 
-      where ${connection(primary)}=${value};
-    `;
-    return result === undefined ? result : filter_null(result);
-  }
-
-  async insert(collection, primary, document) {
-    const { connection } = this;
-    const columns = Object.keys(document);
-    const [result] = await this.connection`insert into
-      ${connection(collection)} 
-      ${columns.length > 0
-    ? connection`(${connection(columns)}) values ${connection(document)}`
-    : connection.unsafe("default values")}
-      returning *;
-    `;
-    return filter_null(result);
-  }
-
-  async update(collection, criteria = {}, delta = {}) {
-    const { connection } = this;
-    return (await connection`
-      update ${connection(collection)}
-      set ${connection({ ...delta })}
-      where ${Object.entries(criteria).reduce((acc, [key, value]) =>
-        connection`${acc} and ${connection(key)} = ${value}`, connection`true`)}
-      returning *;
-    `).length;
-  }
-
-  async delete(collection, criteria = {}) {
-    const { connection } = this;
-    return (await connection`
-      delete from ${connection(collection)}
-      where ${Object.entries(criteria).reduce((acc, [key, value]) =>
-        connection`${acc} and ${connection(key)} = ${value}`, connection`true`)}
-      returning *;
-    `).length;
-  }
-}

package/src/private/connect.js

@@ -1,10 +0,0 @@
-import Driver from "postgres";
-
-export default ({ host, port, database, username, password }) =>
-  new Driver({
-    host,
-    port,
-    db: database,
-    user: username,
-    pass: password,
-  });

package/src/private/defaults.js

@@ -1,4 +0,0 @@
-export default {
-  host: "localhost",
-  port: 5432,
-};

package/src/private/serve.js

@@ -1,63 +0,0 @@
-import Facade from "#Facade";
-import connect from "#connect";
-import ident from "@primate/store/core/ident";
-import wrap from "@primate/store/core/wrap";
-import numeric from "@rcompat/invariant/numeric";
-
-export default options => async () => {
-  const client = connect(options);
-
-  const types = {
-    primary: {
-      validate(value) {
-        if (typeof value === "number" || numeric(value)) {
-          return Number(value);
-        }
-        throw new Error(`\`${value}\` is not a valid primary key value`);
-      },
-      ...ident,
-    },
-    object: {
-      in(value) {
-        return JSON.stringify(value);
-      },
-      out(value) {
-        return JSON.parse(value);
-      },
-    },
-    number: ident,
-    bigint: {
-      in(value) {
-        return value.toString();
-      },
-      out(value) {
-        return BigInt(value);
-      },
-    },
-    boolean: ident,
-    date: {
-      in(value) {
-        return value;
-      },
-      out(value) {
-        return new Date(value);
-      },
-    },
-    string: ident,
-  };
-
-  return {
-    name: "@primate/postgresql",
-    types,
-    async transact(stores) {
-      return (others, next) =>
-        client.begin(async connection => {
-          const facade = new Facade(connection);
-          return next([
-            ...others, ...stores.map(([name, store]) =>
-              [name, wrap(store, facade, types)]),
-          ]);
-        });
-    },
-  };
-};

package/src/private/typemap.js

@@ -1,21 +0,0 @@
-const types = {
-  /* array */
-  blob: "bytea",
-  boolean: "boolean",
-  datetime: "timestamp",
-  embedded: "text",
-  f64: "real",
-  i8: "smallint",
-  i16: "integer",
-  i32: "bigint",
-  i64: "decimal",
-  json: "json",
-  primary: "serial primary key",
-  string: "text",
-  time: "time",
-  u8: "smallint",
-  u16: "integer",
-  u32: "integer",
-};
-
-export default value => types[value];