@idevconn/create-icore 0.11.0 → 0.12.0

package/dist/cli.js

@@ -224,6 +224,7 @@ Re-run with @latest to refresh:
       { value: "supabase", label: "Supabase" },
       { value: "firebase", label: "Firebase" },
       { value: "mongodb", label: "MongoDB (Custom Auth)" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js + bcrypt + JWT)" },
       { value: "none", label: "None \u2014 no login, open API (simple SPA)" }
     ]
   });
@@ -411,7 +412,7 @@ async function rewriteRootPackageJson(targetDir, opts) {
   const pkg = JSON.parse(raw);
   pkg["name"] = opts.projectName;
   pkg["version"] = "0.0.1";
-  pkg["icoreVersion"] = true ? "0.11.0" : "unknown";
+  pkg["icoreVersion"] = true ? "0.12.0" : "unknown";
   pkg["private"] = true;
   delete pkg.description;
   const transportDeps = TRANSPORT_DEPS[opts.transport];
@@ -1477,6 +1478,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/auth-mongodb": ["libs/auth-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/auth-mongodb", symbol: "MongoDbAuthModule", into: "auth" }
+    },
+    postgres: {
+      libDirs: ["libs/auth-strategies/postgres"],
+      deps: { postgres: "^3", bcrypt: "^6", jsonwebtoken: "^9" },
+      tsPaths: { "@icore/auth-postgres": ["libs/auth-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/auth-postgres",
+        symbol: "PostgresAuthModule",
+        into: "auth"
+      }
     }
   },
   storage: {

package/dist/index.cjs

@@ -1187,6 +1187,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/auth-mongodb": ["libs/auth-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/auth-mongodb", symbol: "MongoDbAuthModule", into: "auth" }
+    },
+    postgres: {
+      libDirs: ["libs/auth-strategies/postgres"],
+      deps: { postgres: "^3", bcrypt: "^6", jsonwebtoken: "^9" },
+      tsPaths: { "@icore/auth-postgres": ["libs/auth-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/auth-postgres",
+        symbol: "PostgresAuthModule",
+        into: "auth"
+      }
     }
   },
   storage: {
@@ -2248,6 +2258,7 @@ Re-run with @latest to refresh:
       { value: "supabase", label: "Supabase" },
       { value: "firebase", label: "Firebase" },
       { value: "mongodb", label: "MongoDB (Custom Auth)" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js + bcrypt + JWT)" },
       { value: "none", label: "None \u2014 no login, open API (simple SPA)" }
     ]
   });

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-type AuthBackend = 'supabase' | 'firebase' | 'mongodb';
+type AuthBackend = 'supabase' | 'firebase' | 'mongodb' | 'postgres';
 type AuthProvider = AuthBackend | 'none';
 type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'postgres' | 'none';
 type UploadProvider = 'supabase' | 'firebase' | 'cloudinary' | 'mongodb' | 'none';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-type AuthBackend = 'supabase' | 'firebase' | 'mongodb';
+type AuthBackend = 'supabase' | 'firebase' | 'mongodb' | 'postgres';
 type AuthProvider = AuthBackend | 'none';
 type DbProvider = 'supabase' | 'firebase' | 'mongodb' | 'postgres' | 'none';
 type UploadProvider = 'supabase' | 'firebase' | 'cloudinary' | 'mongodb' | 'none';

package/dist/index.js

@@ -1144,6 +1144,16 @@ var MANIFEST = {
       deps: { mongoose: "^9.6.3" },
       tsPaths: { "@icore/auth-mongodb": ["libs/auth-strategies/mongodb/src/index.ts"] },
       nestModule: { importFrom: "@icore/auth-mongodb", symbol: "MongoDbAuthModule", into: "auth" }
+    },
+    postgres: {
+      libDirs: ["libs/auth-strategies/postgres"],
+      deps: { postgres: "^3", bcrypt: "^6", jsonwebtoken: "^9" },
+      tsPaths: { "@icore/auth-postgres": ["libs/auth-strategies/postgres/src/index.ts"] },
+      nestModule: {
+        importFrom: "@icore/auth-postgres",
+        symbol: "PostgresAuthModule",
+        into: "auth"
+      }
     }
   },
   storage: {
@@ -2205,6 +2215,7 @@ Re-run with @latest to refresh:
       { value: "supabase", label: "Supabase" },
       { value: "firebase", label: "Firebase" },
       { value: "mongodb", label: "MongoDB (Custom Auth)" },
+      { value: "postgres", label: "PostgreSQL (direct, postgres.js + bcrypt + JWT)" },
       { value: "none", label: "None \u2014 no login, open API (simple SPA)" }
     ]
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idevconn/create-icore",
-  "version": "0.11.0",
+  "version": "0.12.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/libs/auth-strategies/postgres/eslint.config.mjs

@@ -0,0 +1,32 @@
+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',
+            'bcrypt',
+            'jsonwebtoken',
+            'postgres',
+            '@nestjs/common',
+            '@nestjs/config',
+            '@nestjs/testing',
+            'vitest',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

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

@@ -0,0 +1,23 @@
+{
+  "name": "@icore/auth-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",
+    "bcrypt": "^6.0.0",
+    "jsonwebtoken": "^9.0.3",
+    "postgres": "^3.4.5",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@nestjs/testing": "^11.1.27",
+    "@types/bcrypt": "^6.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "vitest": "^4.1.9"
+  }
+}

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { runAuthContract } from '@icore/shared/testing';
+import { createMockPostgresAuth } from '../testing/mock-postgres-auth.js';
+
+runAuthContract('PostgresAuthStrategy', () => createMockPostgresAuth());

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

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { Global, Module } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { PostgresAuthModule, POSTGRES_AUTH_REQUIRED_ENV } from '../postgres-auth.module.js';
+import { PostgresAuthStrategy } from '../postgres-auth.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('PostgresAuthModule', () => {
+  it('declares its required env', () => {
+    expect(POSTGRES_AUTH_REQUIRED_ENV).toEqual(['POSTGRES_URL', 'JWT_SECRET']);
+  });
+
+  it('provides a real PostgresAuthStrategy under AuthStrategy when env present', async () => {
+    ENV = {
+      POSTGRES_URL: 'postgresql://user:pass@localhost:5432/test',
+      JWT_SECRET: 'test-secret',
+    };
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, PostgresAuthModule.forRoot('.env')],
+    }).compile();
+    expect(ref.get('AuthStrategy')).toBeInstanceOf(PostgresAuthStrategy);
+  });
+
+  it('provides FakeAuthStrategy when JWT_SECRET is missing', async () => {
+    ENV = { POSTGRES_URL: 'postgresql://user:pass@localhost:5432/test' };
+    const ref = await Test.createTestingModule({
+      imports: [StubConfigModule, PostgresAuthModule.forRoot('.env')],
+    }).compile();
+    const strategy = ref.get('AuthStrategy');
+    expect(strategy).not.toBeInstanceOf(PostgresAuthStrategy);
+  });
+});

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

@@ -0,0 +1,39 @@
+import { Module, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { buildStrategyWithFallback, FakeAuthStrategy } from '@icore/shared';
+import type { AuthStrategy } from '@icore/shared';
+import { PostgresAuthStrategy } from './postgres-auth.strategy';
+
+export const POSTGRES_AUTH_REQUIRED_ENV = ['POSTGRES_URL', 'JWT_SECRET'];
+
+@Module({})
+export class PostgresAuthModule {
+  static forRoot(envPath: string): DynamicModule {
+    return {
+      module: PostgresAuthModule,
+      providers: [
+        {
+          provide: 'AuthStrategy',
+          useFactory: (cfg: ConfigService): AuthStrategy =>
+            buildStrategyWithFallback<AuthStrategy>({
+              service: 'auth MS',
+              provider: 'postgres',
+              requiredEnv: POSTGRES_AUTH_REQUIRED_ENV,
+              cfg,
+              envPath,
+              build: () =>
+                new PostgresAuthStrategy({
+                  url: cfg.getOrThrow<string>('POSTGRES_URL'),
+                  jwtSecret: cfg.getOrThrow<string>('JWT_SECRET'),
+                  jwtExpiresIn: cfg.get<string>('JWT_EXPIRES_IN'),
+                  refreshExpiresIn: cfg.get<string>('JWT_REFRESH_EXPIRES_IN'),
+                }),
+              fake: () => new FakeAuthStrategy(),
+            }),
+          inject: [ConfigService],
+        },
+      ],
+      exports: ['AuthStrategy'],
+    };
+  }
+}

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

@@ -0,0 +1,210 @@
+import postgres from 'postgres';
+import * as bcrypt from 'bcrypt';
+import * as jwt from 'jsonwebtoken';
+import { randomUUID } from 'node:crypto';
+import type {
+  AuthSession,
+  AuthStrategy,
+  MagicLinkRequest,
+  OAuthProvider,
+  OAuthStartResult,
+  VerifiedToken,
+} from '@icore/shared';
+
+export interface PostgresAuthStrategyOptions {
+  url: string;
+  jwtSecret: string;
+  jwtExpiresIn?: string;
+  refreshExpiresIn?: string;
+}
+
+function parseDurationSeconds(s: string): number {
+  const m = /^(\d+)(s|m|h|d)$/.exec(s);
+  if (!m) return 900;
+  const n = parseInt(m[1] as string, 10);
+  const unit = m[2] as string;
+  if (unit === 's') return n;
+  if (unit === 'm') return n * 60;
+  if (unit === 'h') return n * 3600;
+  return n * 86400;
+}
+
+function parseDurationMs(s: string): number {
+  return parseDurationSeconds(s) * 1000;
+}
+
+export class PostgresAuthStrategy implements AuthStrategy {
+  private readonly sql: postgres.Sql;
+  private tablesReadyPromise: Promise<void> | null = null;
+
+  constructor(private readonly opts: PostgresAuthStrategyOptions) {
+    this.sql = postgres(opts.url);
+  }
+
+  private ensureTables(): Promise<void> {
+    if (!this.tablesReadyPromise) {
+      this.tablesReadyPromise = this._createTables();
+    }
+    return this.tablesReadyPromise;
+  }
+
+  private async _createTables(): Promise<void> {
+    await this.sql`
+      CREATE TABLE IF NOT EXISTS _icore_users (
+        id             TEXT PRIMARY KEY,
+        email          TEXT UNIQUE NOT NULL,
+        password_hash  TEXT,
+        role           TEXT,
+        last_logged_in TIMESTAMPTZ,
+        created_at     TIMESTAMPTZ DEFAULT now()
+      )
+    `;
+    await this.sql`
+      CREATE TABLE IF NOT EXISTS _icore_sessions (
+        id             TEXT PRIMARY KEY,
+        user_id        TEXT NOT NULL,
+        refresh_token  TEXT UNIQUE NOT NULL,
+        expires_at     TIMESTAMPTZ NOT NULL
+      )
+    `;
+  }
+
+  async verifyToken(token: string): Promise<VerifiedToken> {
+    try {
+      const decoded = jwt.verify(token, this.opts.jwtSecret) as jwt.JwtPayload;
+      return {
+        uid: decoded.sub as string,
+        email: decoded['email'] as string,
+        role: decoded['role'] as string,
+      };
+    } catch (err) {
+      throw new Error('invalid_token', { cause: err });
+    }
+  }
+
+  async signIn(email: string, password: string): Promise<AuthSession> {
+    await this.ensureTables();
+    const rows = await this.sql<
+      { id: string; email: string; password_hash: string; role: string | null }[]
+    >`
+      SELECT id, email, password_hash, role FROM _icore_users WHERE email = ${email}
+    `;
+    const user = rows[0];
+    if (!user || !user.password_hash) throw new Error('invalid_credentials');
+    const ok = await bcrypt.compare(password, user.password_hash);
+    if (!ok) throw new Error('invalid_credentials');
+    await this.sql`
+      UPDATE _icore_users SET last_logged_in = now() WHERE id = ${user.id}
+    `;
+    return this.createSession({ id: user.id, email: user.email, role: user.role ?? undefined });
+  }
+
+  async signUp(email: string, password: string): Promise<AuthSession> {
+    await this.ensureTables();
+    const id = randomUUID();
+    const passwordHash = await bcrypt.hash(password, 10);
+    try {
+      await this.sql`
+        INSERT INTO _icore_users (id, email, password_hash) VALUES (${id}, ${email}, ${passwordHash})
+      `;
+    } catch (err: unknown) {
+      if (
+        err &&
+        typeof err === 'object' &&
+        'code' in err &&
+        (err as { code: string }).code === '23505'
+      ) {
+        throw new Error('user_already_exists', { cause: err });
+      }
+      throw err;
+    }
+    return this.createSession({ id, email });
+  }
+
+  async refresh(refreshToken: string): Promise<AuthSession> {
+    await this.ensureTables();
+    const sessions = await this.sql<{ id: string; user_id: string; expires_at: Date }[]>`
+      SELECT id, user_id, expires_at FROM _icore_sessions WHERE refresh_token = ${refreshToken}
+    `;
+    const session = sessions[0];
+    if (!session || session.expires_at < new Date()) {
+      if (session) {
+        await this.sql`DELETE FROM _icore_sessions WHERE id = ${session.id}`;
+      }
+      throw new Error('invalid_refresh_token');
+    }
+    const users = await this.sql<{ id: string; email: string; role: string | null }[]>`
+      SELECT id, email, role FROM _icore_users WHERE id = ${session.user_id}
+    `;
+    const user = users[0];
+    if (!user) throw new Error('user_not_found');
+    await this.sql`DELETE FROM _icore_sessions WHERE id = ${session.id}`;
+    await this.sql`
+      UPDATE _icore_users SET last_logged_in = now() WHERE id = ${user.id}
+    `;
+    return this.createSession({ id: user.id, email: user.email, role: user.role ?? undefined });
+  }
+
+  async setRole(uid: string, role: string): Promise<void> {
+    await this.ensureTables();
+    await this.sql`UPDATE _icore_users SET role = ${role} WHERE id = ${uid}`;
+  }
+
+  async getRole(uid: string): Promise<string | null> {
+    await this.ensureTables();
+    const rows = await this.sql<{ role: string | null }[]>`
+      SELECT role FROM _icore_users WHERE id = ${uid}
+    `;
+    return rows[0]?.role ?? null;
+  }
+
+  async sendMagicLink(_req: MagicLinkRequest): Promise<void> {
+    throw new Error('not_implemented');
+  }
+
+  async verifyMagicLink(_token: string): Promise<AuthSession> {
+    throw new Error('not_implemented');
+  }
+
+  async startOAuth(_provider: OAuthProvider, _callbackUrl: string): Promise<OAuthStartResult> {
+    throw new Error('not_implemented');
+  }
+
+  async completeOAuth(
+    _provider: OAuthProvider,
+    _code: string,
+    _state: string,
+  ): Promise<AuthSession> {
+    throw new Error('not_implemented');
+  }
+
+  private async createSession(user: {
+    id: string;
+    email: string;
+    role?: string;
+  }): Promise<AuthSession> {
+    const expiresIn = this.opts.jwtExpiresIn ?? '15m';
+    const accessToken = jwt.sign(
+      { sub: user.id, email: user.email, role: user.role },
+      this.opts.jwtSecret,
+      { expiresIn: expiresIn as jwt.SignOptions['expiresIn'] },
+    );
+    const refreshToken = randomUUID();
+    const refreshMs = parseDurationMs(this.opts.refreshExpiresIn ?? '7d');
+    const expiresAt = new Date(Date.now() + refreshMs);
+    await this.sql`
+      INSERT INTO _icore_sessions (id, user_id, refresh_token, expires_at)
+      VALUES (${randomUUID()}, ${user.id}, ${refreshToken}, ${expiresAt})
+    `;
+    return {
+      accessToken,
+      refreshToken,
+      expiresIn: parseDurationSeconds(expiresIn),
+      user: { id: user.id, email: user.email },
+    };
+  }
+
+  async end(): Promise<void> {
+    await this.sql.end();
+  }
+}

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

@@ -0,0 +1,106 @@
+import { randomUUID } from 'node:crypto';
+import * as bcrypt from 'bcrypt';
+import * as jwt from 'jsonwebtoken';
+import type {
+  AuthSession,
+  AuthStrategy,
+  MagicLinkRequest,
+  OAuthProvider,
+  OAuthStartResult,
+  VerifiedToken,
+} from '@icore/shared';
+
+const MOCK_JWT_SECRET = 'mock-test-secret';
+
+export function createMockPostgresAuth(): AuthStrategy {
+  const users = new Map<
+    string,
+    { id: string; email: string; passwordHash: string; role?: string }
+  >();
+  const sessions = new Map<string, { userId: string; expiresAt: Date }>();
+
+  function buildSession(user: { id: string; email: string; role?: string }): AuthSession {
+    const accessToken = jwt.sign(
+      { sub: user.id, email: user.email, role: user.role },
+      MOCK_JWT_SECRET,
+      { expiresIn: '1h' },
+    );
+    const refreshToken = randomUUID();
+    sessions.set(refreshToken, {
+      userId: user.id,
+      expiresAt: new Date(Date.now() + 7 * 86400 * 1000),
+    });
+    return { accessToken, refreshToken, expiresIn: 3600, user: { id: user.id, email: user.email } };
+  }
+
+  return {
+    async signUp(email: string, password: string): Promise<AuthSession> {
+      if ([...users.values()].find((u) => u.email === email)) {
+        throw new Error('user_already_exists');
+      }
+      const id = randomUUID();
+      const passwordHash = await bcrypt.hash(password, 10);
+      users.set(id, { id, email, passwordHash });
+      return buildSession({ id, email });
+    },
+
+    async signIn(email: string, password: string): Promise<AuthSession> {
+      const user = [...users.values()].find((u) => u.email === email);
+      if (!user) throw new Error('invalid_credentials');
+      const ok = await bcrypt.compare(password, user.passwordHash);
+      if (!ok) throw new Error('invalid_credentials');
+      return buildSession(user);
+    },
+
+    async verifyToken(token: string): Promise<VerifiedToken> {
+      try {
+        const decoded = jwt.verify(token, MOCK_JWT_SECRET) as jwt.JwtPayload;
+        return {
+          uid: decoded.sub as string,
+          email: decoded['email'] as string,
+          role: decoded['role'] as string,
+        };
+      } catch (err) {
+        throw new Error('invalid_token', { cause: err });
+      }
+    },
+
+    async refresh(refreshToken: string): Promise<AuthSession> {
+      const session = sessions.get(refreshToken);
+      if (!session || session.expiresAt < new Date()) {
+        sessions.delete(refreshToken);
+        throw new Error('invalid_refresh_token');
+      }
+      const user = users.get(session.userId);
+      if (!user) throw new Error('user_not_found');
+      sessions.delete(refreshToken);
+      return buildSession(user);
+    },
+
+    async setRole(uid: string, role: string): Promise<void> {
+      const user = users.get(uid);
+      if (user) user.role = role;
+    },
+
+    async getRole(uid: string): Promise<string | null> {
+      return users.get(uid)?.role ?? null;
+    },
+
+    async sendMagicLink(_req: MagicLinkRequest): Promise<void> {
+      throw new Error('not_implemented');
+    },
+    async verifyMagicLink(_token: string): Promise<AuthSession> {
+      throw new Error('not_implemented');
+    },
+    async startOAuth(_provider: OAuthProvider, _callbackUrl: string): Promise<OAuthStartResult> {
+      throw new Error('not_implemented');
+    },
+    async completeOAuth(
+      _provider: OAuthProvider,
+      _code: string,
+      _state: string,
+    ): Promise<AuthSession> {
+      throw new Error('not_implemented');
+    },
+  };
+}

package/templates/libs/auth-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/auth-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/auth-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/auth-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/auth-strategies/postgres',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'auth-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/auth-strategies/postgres',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/templates/tsconfig.base.json

@@ -35,7 +35,8 @@
       "@icore/firebase-admin": ["./libs/firebase-admin/src/index.ts"],
       "@icore/db-mongodb": ["./libs/db-strategies/mongodb/src/index.ts"],
       "@icore/storage-mongodb": ["./libs/storage-strategies/mongodb/src/index.ts"],
-      "@icore/auth-mongodb": ["./libs/auth-strategies/mongodb/src/index.ts"]
+      "@icore/auth-mongodb": ["./libs/auth-strategies/mongodb/src/index.ts"],
+      "@icore/auth-postgres": ["./libs/auth-strategies/postgres/src/index.ts"]
     }
   },
   "exclude": ["node_modules", "dist", ".nx", "tools/create-icore/templates"]