@idevconn/create-icore 0.10.2 → 0.11.0

package/dist/cli.js

@@ -233,7 +233,8 @@ Re-run with @latest to refresh:
     options: [
       { value: "supabase", label: "Supabase Postgres" },
       { value: "firebase", label: "Firestore" },
-      { value: "mongodb", label: "MongoDB" }
+      { value: "mongodb", label: "MongoDB" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js)" }
     ],
     initialValue: authProvider
   });
@@ -410,7 +411,7 @@ async function rewriteRootPackageJson(targetDir, opts) {
   const pkg = JSON.parse(raw);
   pkg["name"] = opts.projectName;
   pkg["version"] = "0.0.1";
-  pkg["icoreVersion"] = true ? "0.10.2" : "unknown";
+  pkg["icoreVersion"] = true ? "0.11.0" : "unknown";
   pkg["private"] = true;
   delete pkg.description;
   const transportDeps = TRANSPORT_DEPS[opts.transport];
@@ -1538,6 +1539,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/db-mongodb": ["libs/db-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/db-mongodb", symbol: "MongoDbDbModule", into: "notes" }
+    },
+    postgres: {
+      libDirs: ["libs/db-strategies/postgres"],
+      deps: { postgres: "^3" },
+      tsPaths: { "@icore/db-postgres": ["libs/db-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/db-postgres",
+        symbol: "PostgresDbModule",
+        into: "notes"
+      }
     }
   },
   feature: {

package/dist/index.cjs

@@ -1249,6 +1249,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/db-mongodb": ["libs/db-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/db-mongodb", symbol: "MongoDbDbModule", into: "notes" }
+    },
+    postgres: {
+      libDirs: ["libs/db-strategies/postgres"],
+      deps: { postgres: "^3" },
+      tsPaths: { "@icore/db-postgres": ["libs/db-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/db-postgres",
+        symbol: "PostgresDbModule",
+        into: "notes"
+      }
     }
   },
   feature: {
@@ -2247,7 +2257,8 @@ Re-run with @latest to refresh:
     options: [
       { value: "supabase", label: "Supabase Postgres" },
       { value: "firebase", label: "Firestore" },
-      { value: "mongodb", label: "MongoDB" }
+      { value: "mongodb", label: "MongoDB" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js)" }
     ],
     initialValue: authProvider
   });

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 type AuthBackend = 'supabase' | 'firebase' | 'mongodb';
 type AuthProvider = AuthBackend | 'none';
-type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'none';
+type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'postgres' | 'none';
 type UploadProvider = 'supabase' | 'firebase' | 'cloudinary' | 'mongodb' | 'none';
 type PaymentProvider = 'paypal' | 'none';
 type JobsProvider = 'bullmq' | 'none';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 type AuthBackend = 'supabase' | 'firebase' | 'mongodb';
 type AuthProvider = AuthBackend | 'none';
-type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'none';
+type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'postgres' | 'none';
 type UploadProvider = 'supabase' | 'firebase' | 'cloudinary' | 'mongodb' | 'none';
 type PaymentProvider = 'paypal' | 'none';
 type JobsProvider = 'bullmq' | 'none';

package/dist/index.js

@@ -1206,6 +1206,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/db-mongodb": ["libs/db-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/db-mongodb", symbol: "MongoDbDbModule", into: "notes" }
+    },
+    postgres: {
+      libDirs: ["libs/db-strategies/postgres"],
+      deps: { postgres: "^3" },
+      tsPaths: { "@icore/db-postgres": ["libs/db-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/db-postgres",
+        symbol: "PostgresDbModule",
+        into: "notes"
+      }
     }
   },
   feature: {
@@ -2204,7 +2214,8 @@ Re-run with @latest to refresh:
     options: [
       { value: "supabase", label: "Supabase Postgres" },
       { value: "firebase", label: "Firestore" },
-      { value: "mongodb", label: "MongoDB" }
+      { value: "mongodb", label: "MongoDB" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js)" }
     ],
     initialValue: authProvider
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idevconn/create-icore",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Bootstrap a new project from the iCore scaffold (Nx + NestJS + React + Vite + shadcn/Tailwind, swappable auth + storage providers).",
   "license": "Apache-2.0",
   "author": "iDEVconn",

package/templates/docker-compose.yml

@@ -1,4 +1,18 @@
 services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-icore}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-icore}
+      POSTGRES_DB: ${POSTGRES_DB:-icore}
+    ports:
+      - '5432:5432'
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U icore']
+      interval: 5s
+      retries: 10
+    networks: [icore]
+
   redis:
     image: redis:7-alpine
     healthcheck:

package/templates/libs/db-strategies/postgres/eslint.config.mjs

@@ -0,0 +1,30 @@
+import baseConfig from '../../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
+            '{projectRoot}/vitest.config.{js,ts,mjs,mts}',
+          ],
+          ignoredDependencies: [
+            '@icore/shared',
+            'postgres',
+            '@nestjs/common',
+            '@nestjs/config',
+            '@nestjs/testing',
+            'vitest',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

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

@@ -0,0 +1,19 @@
+{
+  "name": "@icore/db-postgres",
+  "version": "0.0.1",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@icore/shared": "*",
+    "@nestjs/common": "^11.1.27",
+    "@nestjs/config": "^4.0.4",
+    "postgres": "^3.4.5",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@nestjs/testing": "^11.1.27",
+    "vitest": "^4.1.9"
+  }
+}

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

@@ -0,0 +1,19 @@
+{
+  "name": "db-postgres",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/db-strategies/postgres/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/db-strategies/postgres",
+        "main": "libs/db-strategies/postgres/src/index.ts",
+        "tsConfig": "libs/db-strategies/postgres/tsconfig.lib.json",
+        "assets": ["libs/db-strategies/postgres/*.md"]
+      }
+    }
+  }
+}

package/templates/libs/db-strategies/postgres/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/postgres-db.strategy';
+export * from './lib/testing/mock-postgres';
+export * from './lib/postgres-db.module';

package/templates/libs/db-strategies/postgres/src/lib/__tests__/postgres-db.contract.unit.test.ts

@@ -0,0 +1,4 @@
+import { runDBContract } from '@icore/shared/testing';
+import { createMockPostgresDB } from '../testing/mock-postgres.js';
+
+runDBContract('PostgresDBStrategy', () => createMockPostgresDB());

package/templates/libs/db-strategies/postgres/src/lib/__tests__/postgres-db.module.unit.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { Global, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { PostgresDbModule, POSTGRES_DB_REQUIRED_ENV } from '../postgres-db.module.js';
+import { PostgresDBStrategy } from '../postgres-db.strategy.js';
+
+let ENV: Record<string, string | undefined> = {};
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: ConfigService,
+      useValue: {
+        get: (k: string) => ENV[k],
+        getOrThrow: (k: string) => ENV[k],
+      },
+    },
+  ],
+  exports: [ConfigService],
+})
+class StubConfigModule {}
+
+describe('PostgresDbModule', () => {
+  it('declares its required env', () => {
+    expect(POSTGRES_DB_REQUIRED_ENV).toEqual(['POSTGRES_URL']);
+  });
+
+  it('provides a real PostgresDBStrategy under DBStrategy when env present', async () => {
+    ENV = { POSTGRES_URL: 'postgresql://user:pass@localhost:5432/test' };
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, PostgresDbModule.forRoot('.env')],
+    }).compile();
+    expect(ref.get('DBStrategy')).toBeInstanceOf(PostgresDBStrategy);
+  });
+});

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

@@ -0,0 +1,33 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { buildStrategyWithFallback, FakeDBStrategy } from '@icore/shared';
+import type { DBStrategy } from '@icore/shared';
+import { PostgresDBStrategy } from './postgres-db.strategy';
+
+export const POSTGRES_DB_REQUIRED_ENV = ['POSTGRES_URL'];
+
+@Module({})
+export class PostgresDbModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: PostgresDbModule,
+      providers: [
+        {
+          provide: 'DBStrategy',
+          useFactory: (cfg: ConfigService): DBStrategy =>
+            buildStrategyWithFallback<DBStrategy>({
+              service: 'notes MS',
+              provider: 'postgres',
+              requiredEnv: POSTGRES_DB_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () => new PostgresDBStrategy(cfg.getOrThrow<string>('POSTGRES_URL')),
+              fake: () => new FakeDBStrategy(),
+            }),
+          inject: [ConfigService],
+        },
+      ],
+      exports: ['DBStrategy'],
+    };
+  }
+}

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"],