@aiao/rxdb-adapter-pglite 0.0.1

package/PGliteClient.d.ts

@@ -0,0 +1,71 @@
+import { DescribeQueryResult, QueryOptions, Results, Transaction } from '@electric-sql/pglite';
+interface PGliteClientOptions {
+    store?: 'memory' | 'idb';
+}
+export interface IPGliteClient {
+    init(dbName: string, options: PGliteClientOptions): Promise<void>;
+    /**
+     * 执行单个 SQL 语句
+     * 使用 PostgreSQL 的"扩展查询"协议消息
+     * @param query 要执行的查询语句
+     * @param params 查询的可选参数
+     * @returns 查询的结果
+     */
+    query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
+    /**
+     * 执行单个 SQL 语句，类似于 query，但使用模板语句，其中模板值将被视为参数
+     *
+     * 使用 PostgreSQL 的"扩展查询"协议消息
+     *
+     * @param query 要执行的查询，参数作为模板值
+     * @returns 查询的结果
+     *
+     * @example
+     * ```ts
+     * const results = await db.sql`SELECT * FROM ${identifier`foo`} WHERE id = ${id}`
+     * ```
+     */
+    sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
+    /**
+     * 执行 SQL 查询，可以包含多个语句
+     * 使用 PostgreSQL 的"简单查询"协议消息
+     * @param query 要执行的查询
+     * @returns 查询的结果
+     */
+    exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
+    /**
+     * 描述查询
+     * @param query 要描述的查询
+     * @returns 查询结果类型的描述
+     */
+    describeQuery(query: string, options?: QueryOptions): Promise<DescribeQueryResult>;
+    /**
+     * 执行事务
+     * @param callback 接收事务对象的回调函数
+     * @returns 事务的结果
+     */
+    transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    /**
+     * 独占运行函数，在函数运行期间不允许其他事务或查询
+     * 这在使用 execProtocol 方法时特别有用，因为它们不会被阻塞，
+     * 也不会阻塞事务和查询使用的锁
+     * @param fn 要运行的函数
+     * @returns 函数的结果
+     */
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+    disconnect(): Promise<void>;
+    version(): Promise<string>;
+}
+export declare class PGliteClient implements IPGliteClient {
+    #private;
+    init(dbName: string, options: PGliteClientOptions): Promise<void>;
+    sql<T>(sqlStrings: TemplateStringsArray, ...params: any[]): Promise<Results<T>>;
+    exec(query: string, options?: QueryOptions): Promise<Array<Results>>;
+    query<T>(query: string, params?: any[], options?: QueryOptions): Promise<Results<T>>;
+    describeQuery(query: string, options?: QueryOptions): Promise<DescribeQueryResult>;
+    transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+    disconnect(): Promise<void>;
+    version(): Promise<string>;
+}
+export {};

package/README.md

@@ -0,0 +1 @@
+# rxdb-adapter-pglite

package/RxDBAdapterPGlite.d.ts

@@ -0,0 +1,33 @@
+import { EntityType, IRepository, IRxDBAdapter, RxDB, RxDBAdapterLocalBase, TransactionFun } from '@aiao/rxdb';
+import { Observable } from 'rxjs';
+import { ADAPTER_NAME, PGliteOptions } from './pglite.interface';
+export declare class RxDBAdapterPGlite extends RxDBAdapterLocalBase implements IRxDBAdapter {
+    #private;
+    private readonly options;
+    /**
+     * 数据库版本
+     */
+    version$: Observable<string>;
+    name: string;
+    constructor(rxdb: RxDB, options: PGliteOptions);
+    connect(): Observable<this>;
+    disconnect(): Promise<void>;
+    /**
+     * 获取版本
+     */
+    version(): Promise<string>;
+    getRepository<T extends EntityType, RT extends IRepository<T>>(EntityType: EntityType): RT;
+    createTable(EntityType: EntityType): Promise<boolean>;
+    isTableExisted(EntityType: EntityType): Promise<boolean>;
+    /**
+     * 判断表是否存在
+     * @param EntityType
+     */
+    isTableExisted$<T extends EntityType>(EntityType: T): Observable<boolean>;
+    transaction(fun: TransactionFun): Promise<any>;
+}
+declare module '@aiao/rxdb' {
+    interface RxDBAdapters {
+        [ADAPTER_NAME]: RxDBAdapterPGlite;
+    }
+}

package/generate_table_create_sql.d.ts

@@ -0,0 +1,4 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { RxDBAdapterPGlite } from './RxDBAdapterPGlite';
+declare const _default: (adapter: RxDBAdapterPGlite, metadata: EntityMetadata) => string;
+export default _default;

package/index.d.ts

@@ -0,0 +1,2 @@
+export { RxdbAdapterPGliteError } from './pglite.utils';
+export * from './RxDBAdapterPGlite';

package/index.js

@@ -0,0 +1,170 @@
+import { RxDBError as _, PropertyType as i, TransactionBeginEvent as b, TransactionCommitEvent as f, TransactionRollbackEvent as w, RxDBAdapterLocalBase as x, getEntityMetadata as E } from "@aiao/rxdb";
+import { Observable as $, shareReplay as T, switchMap as l, from as g, map as u, firstValueFrom as m } from "rxjs";
+import { isFunction as y, isString as R } from "@aiao/utils";
+import { PGlite as q } from "@electric-sql/pglite";
+class v extends _ {
+}
+const A = (s) => {
+  switch (s.type) {
+    case i.uuid:
+      return "uuid";
+    case i.string:
+      return "varchar";
+    case i.json:
+      return "jsonb";
+    case i.number:
+      return "numeric";
+    case i.integer:
+      return "integer";
+    case i.boolean:
+      return "boolean";
+    case i.date:
+      return "timestamptz";
+  }
+}, L = (s) => {
+  switch (s.type) {
+    case i.uuid:
+      return "uuid_ops";
+    case i.string:
+      return "bpchar_ops";
+    case i.json:
+      return "jsonb_ops";
+    case i.number:
+      return "numeric_ops";
+    case i.integer:
+      return "int4_ops";
+    default:
+      throw new Error(`rxDBColumnTypeToPGliteTypeIndexName: type '${s.type}' not support`);
+  }
+}, C = (s, e) => `idx_${s.namespace}_${s.name}_${e.name}`, D = (s, e) => {
+  let t = `CREATE TABLE ${e.namespace}."${e.name}" (`;
+  const r = [], c = [], p = [];
+  e.propertyMap.forEach((n) => {
+    let o = "";
+    o += `"${n.name}"`;
+    const d = A(n);
+    if (n.primary ? n.type === i.integer ? o += " serial PRIMARY KEY" : o += ` ${d} PRIMARY KEY` : o += ` ${d}`, !n.nullable) o += " NOT NULL";
+    else if (Reflect.get(n, "default") !== void 0) {
+      let a = n.default;
+      y(n.default) && (a = n.default()), R(a) ? ["CURRENT_TIMESTAMP", "now()"].includes(a) ? o += " DEFAULT now()" : o += ` DEFAULT '${a}'` : o += ` DEFAULT ${String(a)}`;
+    }
+    n.unique && r.push(
+      `CREATE UNIQUE INDEX "${C(e, n)}" on ${e.namespace}."${e.name}" ("${n.name}" ${L(n)});`
+    ), p.push(o);
+  });
+  const h = [...p, ...c];
+  if (h.length)
+    t += h.map((n) => `
+${n}`).join(","), t += `
+);`;
+  else
+    throw new v("columns is empty!");
+  return r.length && (t += `
+` + r.join(`
+`)), t;
+}, M = (s, e) => "", P = (s, e) => {
+  let t = "";
+  return t += D(s, e), t += M(), t;
+}, S = "pglite";
+class N {
+  #e;
+  async init(e, t) {
+    return this.#e = new q({
+      dataDir: t.store === "memory" ? void 0 : `idb://${e}`,
+      database: e
+    }), this.#e.waitReady;
+  }
+  sql(e, ...t) {
+    return this.#e.sql(e, ...t);
+  }
+  exec(e, t) {
+    return this.#e.exec(e, t);
+  }
+  query(e, t, r) {
+    return this.#e.query(e, t, r);
+  }
+  describeQuery(e, t) {
+    return this.#e.describeQuery(e, t);
+  }
+  transaction(e) {
+    return this.#e.transaction(e);
+  }
+  runExclusive(e) {
+    return this.#e.runExclusive(e);
+  }
+  disconnect() {
+    throw new Error("Method not implemented.");
+  }
+  async version() {
+    return (await this.#e.query("SELECT version()")).rows[0].version;
+  }
+}
+class U extends x {
+  constructor(e, t) {
+    super(e), this.options = t;
+  }
+  #e = new $((e) => {
+    const t = new N();
+    t.init(this.rxdb.options.dbName, this.options).then(() => e.next(t));
+  }).pipe(T(1));
+  /**
+   * 数据库版本
+   */
+  version$ = this.#e.pipe(
+    l((e) => g(e.version())),
+    T(1)
+  );
+  name = S;
+  connect() {
+    return this.#e.pipe(u(() => this));
+  }
+  disconnect() {
+    throw new Error("Method disconnect not implemented.");
+  }
+  /**
+   * 获取版本
+   */
+  version() {
+    return m(this.version$);
+  }
+  getRepository(e) {
+    throw new Error("Method getRepository not implemented.");
+  }
+  createTable(e) {
+    const t = E(e), r = P(this, t);
+    return t.log, m(this.#n(r).pipe(u(() => !0)));
+  }
+  async isTableExisted(e) {
+    return m(this.isTableExisted$(e));
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted$(e) {
+    const t = E(e);
+    return this.#t(
+      `SELECT EXISTS (
+    SELECT 1
+    FROM information_schema.tables
+    WHERE table_schema = '${t.namespace}'
+    AND table_name = '${t.name}');`
+    ).pipe(u((r) => r.rows[0]?.exists));
+  }
+  transaction(e) {
+    throw new Error("Method  transaction not implemented.");
+  }
+  #t(e, t, r) {
+    return this.#e.pipe(l((c) => c.query(e, t, r)));
+  }
+  #n(e, t) {
+    return this.#e.pipe(l((r) => r.exec(e, t)));
+  }
+}
+new b();
+new f();
+new w();
+export {
+  U as RxDBAdapterPGlite,
+  v as RxdbAdapterPGliteError
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@aiao/rxdb-adapter-pglite",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "@electric-sql/pglite": "^0.3.6",
+    "@aiao/rxdb": "0.0.1",
+    "rxjs": "~7.8.2",
+    "@aiao/utils": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pglite.interface.d.ts

@@ -0,0 +1,5 @@
+import { IRxDBAdapterOptions } from '@aiao/rxdb';
+export declare const ADAPTER_NAME: "pglite";
+export interface PGliteOptions extends IRxDBAdapterOptions {
+    store?: 'memory' | 'idb';
+}

package/pglite.utils.d.ts

@@ -0,0 +1,16 @@
+import { EntityMetadata, EntityPropertyMetadata, EntityRelationMetadata, RxDBError } from '@aiao/rxdb';
+export declare class RxdbAdapterPGliteError extends RxDBError {
+}
+export declare const getTableNameByMetadata: (metadata: EntityMetadata) => string;
+type PGliteDataType = 'uuid' | 'varchar' | 'jsonb' | 'numeric' | 'integer' | 'boolean' | 'timestamptz';
+/**
+ * rxdb 的类型 转 PGlite 类型
+ */
+export declare const rxDBColumnTypeToPGliteType: (property: EntityPropertyMetadata) => PGliteDataType;
+/**
+ * 获取属性的 index 操作符
+ *http://www.postgres.cn/docs/current/indexes-opclass.html
+ */
+export declare const rxDBColumnTypeToPGliteTypeIndexName: (property: EntityPropertyMetadata) => string;
+export declare const getTableColumnIndexName: (metadata: EntityMetadata, property: EntityPropertyMetadata | EntityRelationMetadata) => string;
+export {};