@idevconn/create-icore 0.10.2 → 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)" }
     ]
   });
@@ -233,7 +234,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 +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.10.2" : "unknown";
+  pkg["icoreVersion"] = true ? "0.12.0" : "unknown";
   pkg["private"] = true;
   delete pkg.description;
   const transportDeps = TRANSPORT_DEPS[opts.transport];
@@ -1476,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: {
@@ -1538,6 +1550,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

@@ -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: {
@@ -1249,6 +1259,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: {
@@ -2238,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)" }
     ]
   });
@@ -2247,7 +2268,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 AuthBackend = 'supabase' | 'firebase' | 'mongodb' | 'postgres';
 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 AuthBackend = 'supabase' | 'firebase' | 'mongodb' | 'postgres';
 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

@@ -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: {
@@ -1206,6 +1216,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: {
@@ -2195,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)" }
     ]
   });
@@ -2204,7 +2225,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.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/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/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();
+  }
+}