@tobi2409/fullsty 0.5.1 → 0.5.3

package/README.md

@@ -56,7 +56,7 @@ Run it from the project root, for example:
 
 ```bash
 ../../scripts/fullsty-server-pkg.js add pg
-../../scripts/fullsty-server-pkg.js add drizzle-orm
+../../scripts/fullsty-server-pkg.js add kysely
 ../../scripts/fullsty-server-pkg.js remove pg
 ```
 
@@ -75,7 +75,7 @@ The script does not manage the project-level [package.json](project-frame/packag
 
 After `fullsty-server-pkg.js add <package>` you should run `npm run generate` again so the updated project server package file is copied into `generated/server/package.json`. After that, run `npm install` again inside [projects/demo1/generated/server](projects/demo1/generated/server) so the generated server gets the updated dependencies.
 
-`fullsty-server-pkg.js add drizzle-orm` copies [scripts/extension-wrappers/drizzle-orm/drizzle-orm-wrapper.ts](scripts/extension-wrappers/drizzle-orm/drizzle-orm-wrapper.ts) into [projects/demo1/src/server](projects/demo1/src/server). This keeps `drizzle-orm` visible as the recommended SQL style without coupling it to a specific DBMS wrapper. For PostgreSQL pooling and env handling you can add `pg` separately.
+`fullsty-server-pkg.js add kysely` copies [scripts/extension-wrappers/kysely/kysely-wrapper.ts](scripts/extension-wrappers/kysely/kysely-wrapper.ts) into [projects/demo1/src/server](projects/demo1/src/server). This keeps `kysely` visible as the recommended SQL style without coupling it to a specific DBMS wrapper. For PostgreSQL pooling and env handling you can add `pg` separately.
 
 ## 5) Start the generated server
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tobi2409/fullsty",
-    "version": "0.5.1",
+    "version": "0.5.3",
     "description": "Fullsty is a modular fullstack framework starter built from three core parts: template-engine, layout and proc2rest. It provides a project frame for building fullstack applications with a clear separation of client and server code.",
     "license": "ISC",
     "author": "Tobias Hollstein",

package/scripts/extension-wrappers/db-connection/db-connection-wrapper.ts

@@ -1,29 +1,41 @@
-// @ts-ignore pg-wrapper is supplied by the pg extension in generated projects.
-import { getPgPool, closeAllPgPools } from "../pg/pg-wrapper";
-
 type DriverName = "pg" | "mysql" | "sqlite";
 
-type ConnectionData = {
+interface ConnectionData {
     connectionName?: string;
 };
 
 export class DbConnection {
+    private connectionWrapper?: unknown;
+
     constructor(
         private readonly driverName: DriverName,
-        private readonly connectionData: ConnectionData = {},
+        private readonly connectionData: ConnectionData = {}
     ) {}
 
-    connect() {
+    getDriverName(): DriverName {
+        return this.driverName;
+    }
+
+    async getConnection(): Promise<unknown> {
         if (this.driverName === "pg") {
-            return getPgPool(this.connectionData.connectionName ?? "default");
+            if (!this.connectionWrapper) {
+                // @ts-ignore pg-wrapper is supplied by the pg extension in generated projects.
+                const { PgConnectionWrapper } = await import("../pg/pg-wrapper.ts");
+                this.connectionWrapper = new PgConnectionWrapper(this.connectionData.connectionName ?? "default");
+            }
+
+            return (this.connectionWrapper as any).getPgPool();
         }
 
         throw new Error(`Driver is not integrated yet: ${this.driverName}`);
     }
 
-    async close() {
+    async close(): Promise<void> {
         if (this.driverName === "pg") {
-            await closeAllPgPools();
+            if (this.connectionWrapper) {
+                await (this.connectionWrapper as any).closePool();
+            }
+
             return;
         }
 

package/scripts/extension-wrappers/kysely/kysely-wrapper.ts

@@ -0,0 +1,29 @@
+// @ts-ignore kysely is supplied by the server package in generated projects.
+import * as k from "kysely";
+
+type DriverName = "pg" | "mysql" | "sqlite";
+
+export namespace KyselyWrapper {
+	export const sql = k.sql;
+
+	export function getKysely(): typeof k {
+		return k;
+	}
+
+	export function buildQueryCompiler(driverName: DriverName): k.Kysely<any> {
+		const kysely = getKysely() as any;
+
+		if (driverName === "pg") {
+			return new kysely.Kysely({
+				dialect: {
+					createAdapter: () => new kysely.PostgresAdapter(),
+					createDriver: () => new kysely.DummyDriver(),
+					createIntrospector: (db: any) => new kysely.PostgresIntrospector(db),
+					createQueryCompiler: () => new kysely.PostgresQueryCompiler(),
+				}
+			});
+		}
+
+		throw new Error(`Driver is not integrated yet: ${driverName}`);
+	}
+}

package/scripts/extension-wrappers/pg/pg-wrapper.ts

@@ -1,82 +1,73 @@
+// @ts-ignore pg dependencies are supplied by the server package in generated projects.
 import dotenv from "dotenv";
+// @ts-ignore node types are supplied by the server package in generated projects.
 import fs from "fs";
+// @ts-ignore node types are supplied by the server package in generated projects.
 import path from "path";
+// @ts-ignore pg dependencies are supplied by the server package in generated projects.
 import { Pool } from "pg";
+// @ts-ignore node types are supplied by the server package in generated projects.
 import { fileURLToPath } from "url";
 
-const pools = new Map<string, Pool>();
-let pgEnv: Record<string, string> = {};
-let pgEnvLoaded = false;
-const wrapperDir = path.dirname(fileURLToPath(import.meta.url));
-const envFilePath = path.join(wrapperDir, ".env.pg");
+export class PgConnectionWrapper {
+    private pool: Pool | null = null;
+    private pgEnv: Record<string, string> = {};
+    private pgEnvLoaded: boolean = false;
+    private readonly wrapperDir: string = path.dirname(fileURLToPath(import.meta.url));
+    private readonly envFilePath: string = path.join(this.wrapperDir, ".env.pg");
 
-function envKey(connectionName: string, key: string): string {
-    const prefix = connectionName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
-    return `${prefix}_${key}`;
-}
+    constructor(private readonly connectionName: string = "default") {}
 
-function loadPgEnv(): void {
-    if (pgEnvLoaded) {
-        return;
+    private envKey(key: string): string {
+        const prefix = this.connectionName.toUpperCase().replace(/[^A-Z0-9_]/g, "_");
+        return `${prefix}_${key}`;
     }
 
-    // Load .env.pg into a local cache instead of writing into process.env.
-    // This keeps the pg wrapper isolated from other wrappers such as auth,
-    // which may load their own .env files later.
-    const envFileContent = fs.existsSync(envFilePath)
-        ? fs.readFileSync(envFilePath, "utf8")
-        : "";
+    private loadPgEnv(): void {
+        // only load the .env.pg file once
+        if (this.pgEnvLoaded) {
+            return;
+        }
 
-    pgEnv = dotenv.parse(envFileContent);
-    pgEnvLoaded = true;
-}
+        // Load .env.pg into a local cache instead of writing into process.env.
+        // This keeps the pg wrapper isolated from other wrappers such as auth,
+        // which may load their own .env files later.
+        const envFileContent = fs.existsSync(this.envFilePath)
+            ? fs.readFileSync(this.envFilePath, "utf8")
+            : "";
 
-function getEnv(
-    connectionName: string,
-    key: string,
-    fallback?: string,
-): string {
-    loadPgEnv();
-    return pgEnv[envKey(connectionName, key)] ?? fallback ?? "";
-}
-
-export function getPgPool(connectionName: string = "default"): Pool {
-    const existing = pools.get(connectionName);
-    if (existing) {
-        return existing;
+        this.pgEnv = dotenv.parse(envFileContent);
+        this.pgEnvLoaded = true;
     }
 
-    const pool = new Pool({
-        host: getEnv(connectionName, "PGHOST", "127.0.0.1"),
-        port: Number(getEnv(connectionName, "PGPORT", "5432")),
-        user: getEnv(connectionName, "PGUSER", "postgres"),
-        password: getEnv(connectionName, "PGPASSWORD", "postgres"),
-        database: getEnv(connectionName, "PGDATABASE", "fullsty_demo"),
-        max: Number(getEnv(connectionName, "POOL_MAX", "10")),
-    });
+    private getEnv(key: string, fallback?: string): string {
+        this.loadPgEnv();
+        return this.pgEnv[this.envKey(key)] ?? fallback ?? "";
+    }
 
-    pools.set(connectionName, pool);
-    return pool;
-}
+    getPgPool(): Pool {
+        if (this.pool) {
+            return this.pool;
+        }
 
-export async function closePgPool(
-    connectionName: string = "default",
-): Promise<void> {
-    const pool = pools.get(connectionName);
+        this.pool = new Pool({
+            host: this.getEnv("PGHOST", "127.0.0.1"),
+            port: Number(this.getEnv("PGPORT", "5432")),
+            user: this.getEnv("PGUSER", "postgres"),
+            password: this.getEnv("PGPASSWORD", "postgres"),
+            database: this.getEnv("PGDATABASE", "fullsty_demo"),
+            max: Number(this.getEnv("POOL_MAX", "10"))
+        });
 
-    if (!pool) {
-        return;
+        return this.pool;
     }
 
-    await pool.end();
-    pools.delete(connectionName);
-}
-
-export async function closeAllPgPools(): Promise<void> {
-    const all = [...pools.entries()];
+    async closePool(): Promise<void> {
+        if (!this.pool) {
+            return;
+        }
 
-    for (const [name, pool] of all) {
-        await pool.end();
-        pools.delete(name);
+        await this.pool.end();
+        this.pool = null;
     }
-}
+}

package/scripts/extension-wrappers/drizzle-orm/drizzle-orm-wrapper.ts

@@ -1 +0,0 @@
-export { sql } from "drizzle-orm";