@idevconn/create-icore 0.10.1 → 0.11.0

package/templates/libs/db-strategies/postgres/src/lib/postgres-db.strategy.ts

@@ -0,0 +1,139 @@
+import postgres from 'postgres';
+import type { DBDocument, DBStrategy, QueryOptions } from '@icore/shared';
+
+export class PostgresDBStrategy implements DBStrategy {
+  private readonly sql: postgres.Sql;
+  private readonly initializing = new Map<string, Promise<void>>();
+  private readonly initialized = new Set<string>();
+
+  constructor(url: string) {
+    this.sql = postgres(url);
+  }
+
+  private async ensureTable(collection: string): Promise<void> {
+    if (this.initialized.has(collection)) return;
+    let inflight = this.initializing.get(collection);
+    if (inflight) return inflight;
+    inflight = this._createTable(collection).catch((err) => {
+      this.initializing.delete(collection);
+      throw err;
+    });
+    this.initializing.set(collection, inflight);
+    return inflight;
+  }
+
+  private async _createTable(collection: string): Promise<void> {
+    await this.sql`
+      CREATE TABLE IF NOT EXISTS ${this.sql(collection)} (
+        id   TEXT PRIMARY KEY,
+        data JSONB NOT NULL
+      )
+    `;
+    await this.sql`
+      CREATE INDEX IF NOT EXISTS ${this.sql(collection + '_data_gin')}
+      ON ${this.sql(collection)} USING GIN (data)
+    `;
+    this.initialized.add(collection);
+    this.initializing.delete(collection);
+  }
+
+  async get<T>(collection: string, id: string): Promise<DBDocument<T> | null> {
+    await this.ensureTable(collection);
+    const rows = await this.sql<{ id: string; data: T }[]>`
+      SELECT id, data FROM ${this.sql(collection)} WHERE id = ${id}
+    `;
+    const row = rows[0];
+    if (!row) return null;
+    return { id: row.id, data: row.data };
+  }
+
+  async set<T>(collection: string, id: string, data: T): Promise<void> {
+    await this.ensureTable(collection);
+    await this.sql`
+      INSERT INTO ${this.sql(collection)} (id, data)
+      VALUES (${id}, ${this.sql.json(data as unknown as postgres.JSONValue)})
+      ON CONFLICT (id) DO UPDATE SET data = EXCLUDED.data
+    `;
+  }
+
+  async update<T>(collection: string, id: string, patch: Partial<T>): Promise<void> {
+    await this.ensureTable(collection);
+    const rows = await this.sql`
+      UPDATE ${this.sql(collection)}
+      SET data = data || ${this.sql.json(patch as postgres.JSONValue)}
+      WHERE id = ${id}
+      RETURNING id
+    `;
+    if (rows.count === 0) throw new Error(`not_found: ${collection}/${id}`);
+  }
+
+  async delete(collection: string, id: string): Promise<void> {
+    await this.ensureTable(collection);
+    const rows = await this.sql`
+      DELETE FROM ${this.sql(collection)} WHERE id = ${id} RETURNING id
+    `;
+    if (rows.count === 0) throw new Error(`not_found: ${collection}/${id}`);
+  }
+
+  async list<T>(collection: string, opts?: QueryOptions): Promise<DBDocument<T>[]> {
+    await this.ensureTable(collection);
+
+    const conditions: postgres.Fragment[] = [];
+
+    if (opts?.where) {
+      for (const c of opts.where) {
+        const field = c.field;
+        if (c.op === '==' || c.op === '!=') {
+          const expr = field === 'id' ? this.sql`id` : this.sql`data->>${field}`;
+          conditions.push(
+            c.op === '=='
+              ? this.sql`${expr} = ${String(c.value)}`
+              : this.sql`${expr} != ${String(c.value)}`,
+          );
+        } else if (c.op === 'in') {
+          const vals = (c.value as unknown[]).map(String);
+          const expr = field === 'id' ? this.sql`id` : this.sql`data->>${field}`;
+          conditions.push(this.sql`${expr} = ANY(${vals})`);
+        } else {
+          // numeric ops: <, <=, >, >=
+          const expr =
+            field === 'id' ? this.sql`id::numeric` : this.sql`(data->>${field})::numeric`;
+          const val = Number(c.value);
+          if (c.op === '<') conditions.push(this.sql`${expr} < ${val}`);
+          else if (c.op === '<=') conditions.push(this.sql`${expr} <= ${val}`);
+          else if (c.op === '>') conditions.push(this.sql`${expr} > ${val}`);
+          else if (c.op === '>=') conditions.push(this.sql`${expr} >= ${val}`);
+        }
+      }
+    }
+
+    const whereClause =
+      conditions.length > 0
+        ? this.sql`WHERE ${conditions.reduce((acc, c) => this.sql`${acc} AND ${c}`)}`
+        : this.sql``;
+
+    const orderBy = opts?.orderBy;
+    const orderClause = orderBy
+      ? (() => {
+          const col = orderBy.field === 'id' ? this.sql`id` : this.sql`data->>${orderBy.field}`;
+          const dir = orderBy.direction === 'desc' ? this.sql`DESC` : this.sql`ASC`;
+          return this.sql`ORDER BY ${col} ${dir}`;
+        })()
+      : this.sql``;
+
+    const limitClause = opts?.limit != null ? this.sql`LIMIT ${opts.limit}` : this.sql``;
+
+    const rows = await this.sql<{ id: string; data: T }[]>`
+      SELECT id, data FROM ${this.sql(collection)}
+      ${whereClause}
+      ${orderClause}
+      ${limitClause}
+    `;
+
+    return rows.map((row) => ({ id: row.id, data: row.data }));
+  }
+
+  async end(): Promise<void> {
+    await this.sql.end();
+  }
+}

package/templates/libs/db-strategies/postgres/src/lib/testing/mock-postgres.ts

@@ -0,0 +1,94 @@
+import type { DBDocument, DBStrategy, QueryOptions } from '@icore/shared';
+
+function applyOp(val: unknown, op: string, target: unknown): boolean {
+  switch (op) {
+    case '==':
+      return String(val) === String(target);
+    case '!=':
+      return String(val) !== String(target);
+    case '<':
+      return Number(val) < Number(target);
+    case '<=':
+      return Number(val) <= Number(target);
+    case '>':
+      return Number(val) > Number(target);
+    case '>=':
+      return Number(val) >= Number(target);
+    case 'in':
+      return Array.isArray(target) && (target as unknown[]).map(String).includes(String(val));
+    default:
+      return false;
+  }
+}
+
+function resolveField(data: Record<string, unknown>, id: string, field: string): unknown {
+  if (field === 'id') return id;
+  return data[field];
+}
+
+export function createMockPostgresDB(): DBStrategy {
+  const store = new Map<string, Map<string, Record<string, unknown>>>();
+
+  function getTable(collection: string): Map<string, Record<string, unknown>> {
+    let t = store.get(collection);
+    if (!t) {
+      t = new Map();
+      store.set(collection, t);
+    }
+    return t;
+  }
+
+  return {
+    async get<T>(collection: string, id: string): Promise<DBDocument<T> | null> {
+      const row = getTable(collection).get(id);
+      if (!row) return null;
+      return { id, data: row as T };
+    },
+
+    async set<T>(collection: string, id: string, data: T): Promise<void> {
+      getTable(collection).set(id, { ...(data as Record<string, unknown>) });
+    },
+
+    async update<T>(collection: string, id: string, patch: Partial<T>): Promise<void> {
+      const table = getTable(collection);
+      const existing = table.get(id);
+      if (!existing) throw new Error(`not_found: ${collection}/${id}`);
+      table.set(id, { ...existing, ...(patch as Record<string, unknown>) });
+    },
+
+    async delete(collection: string, id: string): Promise<void> {
+      const table = getTable(collection);
+      if (!table.has(id)) throw new Error(`not_found: ${collection}/${id}`);
+      table.delete(id);
+    },
+
+    async list<T>(collection: string, opts?: QueryOptions): Promise<DBDocument<T>[]> {
+      let entries = [...getTable(collection).entries()].map(([id, data]) => ({ id, data }));
+
+      if (opts?.where) {
+        for (const c of opts.where) {
+          entries = entries.filter((e) => {
+            const val = resolveField(e.data, e.id, c.field);
+            return applyOp(val, c.op, c.value);
+          });
+        }
+      }
+
+      if (opts?.orderBy) {
+        const { field, direction } = opts.orderBy;
+        entries.sort((a, b) => {
+          const av = resolveField(a.data, a.id, field);
+          const bv = resolveField(b.data, b.id, field);
+          const cmp = String(av) < String(bv) ? -1 : String(av) > String(bv) ? 1 : 0;
+          return direction === 'desc' ? -cmp : cmp;
+        });
+      }
+
+      if (opts?.limit != null) {
+        entries = entries.slice(0, opts.limit);
+      }
+
+      return entries.map((e) => ({ id: e.id, data: e.data as T }));
+    },
+  };
+}

package/templates/libs/db-strategies/postgres/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "node16",
+    "moduleResolution": "node16",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [{ "path": "./tsconfig.lib.json" }, { "path": "./tsconfig.spec.json" }]
+}

package/templates/libs/db-strategies/postgres/tsconfig.lib.json

@@ -0,0 +1,24 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "rootDir": "../../..",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/templates/libs/db-strategies/postgres/tsconfig.spec.json

@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node", "vitest"]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/templates/libs/db-strategies/postgres/vitest.config.mts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../../node_modules/.vite/libs/db-strategies/postgres',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'db-postgres',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    passWithNoTests: true,
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../../coverage/libs/db-strategies/postgres',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/templates/tsconfig.base.json

@@ -27,6 +27,7 @@
       "@idevconn/create-icore": ["./tools/create-icore/src/index.ts"],
       "@icore/db-supabase": ["./libs/db-strategies/supabase/src/index.ts"],
       "@icore/db-firestore": ["./libs/db-strategies/firestore/src/index.ts"],
+      "@icore/db-postgres": ["./libs/db-strategies/postgres/src/index.ts"],
       "@icore/payment-client": ["./libs/payment-client/src/index.ts"],
       "@icore/notes-client": ["./libs/notes-client/src/index.ts"],
       "@icore/jobs-client": ["./libs/jobs-client/src/index.ts"],