@tobi2409/fullsty 0.5.12 → 0.8.0

package/README.md

@@ -21,7 +21,7 @@ For the `db-test` demo, add the required server wrappers in your project root be
 ```bash
 fullsty-server-pkg add pg
 fullsty-server-pkg add db-connection
-fullsty-server-pkg add kysely
+fullsty-server-pkg add drizzle
 ```
 
 ## 1) Create a project
@@ -66,7 +66,7 @@ Run it from the project root, for example:
 
 ```bash
 fullsty-server-pkg add pg
-fullsty-server-pkg add kysely
+fullsty-server-pkg add drizzle
 fullsty-server-pkg remove pg
 ```
 
@@ -83,9 +83,14 @@ What it does:
 
 The script does not manage the project-level [package.json](project-frame/package.json).
 
+The wrapper in `scripts/extension-wrappers` is the single source of truth. The
+copied files under `src/server` and the generated files under `generated/server`
+are derived artifacts and should not be edited manually. Re-run the wrapper
+command and `npm run generate` after changing an extension or its dependencies.
+
 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 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.
+`fullsty-server-pkg.js add drizzle` copies [scripts/extension-wrappers/drizzle/drizzle-wrapper.ts](scripts/extension-wrappers/drizzle/drizzle-wrapper.ts) into [projects/demo1/src/server](projects/demo1/src/server). This keeps Drizzle 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.12",
+    "version": "0.8.0",
     "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/@tobi2409/authentication-core-db/current-user.ts

@@ -1,6 +1,6 @@
 import { DbConnection } from '../../db-connection/db-connection-wrapper.ts'
-// @ts-ignore kysely is supplied by the server package in generated projects.
-import { KyselyWrapper } from '../../kysely/kysely-wrapper.ts'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { DrizzleWrapper } from '../../drizzle/drizzle-wrapper.ts'
 import { authenticationCoreLib } from '../../@tobi2409/authentication-core-lib/authentication-core-lib-wrapper.ts'
 import {
     DEFAULT_TABLE_NAME,
@@ -8,7 +8,7 @@ import {
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreKyselyCurrentUser {
+export namespace AuthenticationCoreDrizzleCurrentUser {
     export async function getCurrentUser(
         token: string,
         jwtKey: Parameters<
@@ -22,36 +22,31 @@ export namespace AuthenticationCoreKyselyCurrentUser {
         >[3] = {}
     ): Promise<string> {
         try {
-            const db = KyselyWrapper.buildQueryCompiler(
+            // The wrapper only stores the driver name and is very lightweight;
+            // the pool is supplied per query context, so repeated initialization is safe.
+            const drizzleWrapper = new DrizzleWrapper(
                 dbConnection.getDriverName()
             )
+            const db = drizzleWrapper.buildQueryBuilder(
+                await dbConnection.getPool()
+            )
+            const users = drizzleWrapper.buildTable(tableName, columns, {
+                uuid: 'uuid',
+                isActive: 'boolean'
+            })
 
             const isActiveCallback = async (uuid: string): Promise<boolean> => {
-                const compiledQuery = db
-                    .selectFrom(tableName)
-                    .select([
-                        KyselyWrapper.sql.ref(columns.isActive).as('isActive')
-                    ])
-                    .where(KyselyWrapper.sql.ref(columns.uuid), '=', uuid)
+                const result = await db
+                    .select({ isActive: users.isActive })
+                    .from(users)
+                    .where(DrizzleWrapper.eq(users.uuid, uuid))
                     .limit(1)
-                    .compile()
-
-                // 'any' is used instead of 'unknown' because calling .query() on an unknown type requires
-                // either a type assertion or a separate interface. DbConnection is driver-agnostic, so
-                // the concrete pool type (e.g. pg.Pool) is not available here without adding a dependency.
-                const connection = (await dbConnection.getConnection()) as any
-                const result = await connection.query(
-                    compiledQuery.sql,
-                    compiledQuery.parameters
-                )
 
-                if (!result.rows?.[0]) {
+                if (!result[0]) {
                     return false
                 }
 
-                return Boolean(
-                    (result.rows[0] as Record<string, unknown>).isActive
-                )
+                return Boolean(result[0].isActive)
             }
 
             return authenticationCoreLib.AuthenticationCoreCurrentUser.getCurrentUser(

package/scripts/extension-wrappers/@tobi2409/authentication-core-db/extension.json

@@ -1,3 +1,8 @@
 {
-    "addToServerPackage": false
+    "addToServerPackage": false,
+    "dependencies": [
+        "db-connection",
+        "drizzle",
+        "@tobi2409/authentication-core-lib"
+    ]
 }

package/scripts/extension-wrappers/@tobi2409/authentication-core-db/login.ts

@@ -1,6 +1,6 @@
 import { DbConnection } from '../../db-connection/db-connection-wrapper.ts'
-// @ts-ignore kysely is supplied by the server package in generated projects.
-import { KyselyWrapper } from '../../kysely/kysely-wrapper.ts'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { DrizzleWrapper } from '../../drizzle/drizzle-wrapper.ts'
 import { authenticationCoreLib } from '../../@tobi2409/authentication-core-lib/authentication-core-lib-wrapper.ts'
 import {
     DEFAULT_TABLE_NAME,
@@ -8,7 +8,7 @@ import {
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreKyselyLogin {
+export namespace AuthenticationCoreDrizzleLogin {
     function mapFetchedUser(
         row: Record<string, unknown> | undefined
     ): authenticationCoreLib.FetchedUser | undefined {
@@ -38,34 +38,34 @@ export namespace AuthenticationCoreKyselyLogin {
         >[4] = {}
     ): Promise<string> {
         try {
-            const db = KyselyWrapper.buildQueryCompiler(
+            // The wrapper only stores the driver name and is very lightweight;
+            // the pool is supplied per query context, so repeated initialization is safe.
+            const drizzleWrapper = new DrizzleWrapper(
                 dbConnection.getDriverName()
             )
+            const db = drizzleWrapper.buildQueryBuilder(
+                await dbConnection.getPool()
+            )
+            const users = drizzleWrapper.buildTable(tableName, columns, {
+                uuid: 'uuid',
+                isActive: 'boolean'
+            })
 
-            const compiledQuery = db
-                .selectFrom(tableName)
-                .select([
-                    KyselyWrapper.sql.ref(columns.uuid).as('uuid'),
-                    KyselyWrapper.sql.ref(columns.mail).as('mail'),
-                    KyselyWrapper.sql.ref(columns.password).as('password'),
-                    KyselyWrapper.sql.ref(columns.isActive).as('isActive')
-                ])
-                .where(KyselyWrapper.sql.ref(columns.mail), '=', typedMail)
+            const result = await db
+                .select({
+                    uuid: users.uuid,
+                    mail: users.mail,
+                    password: users.password,
+                    isActive: users.isActive
+                })
+                .from(users)
+                .where(DrizzleWrapper.eq(users.mail, typedMail))
                 .limit(1)
-                .compile()
-
-            // 'any' is used instead of 'unknown' because calling .query() on an unknown type requires
-            // either a type assertion or a separate interface. DbConnection is driver-agnostic, so
-            // the concrete pool type (e.g. pg.Pool) is not available here without adding a dependency.
-            const connection = (await dbConnection.getConnection()) as any
-            const result = await connection.query(
-                compiledQuery.sql,
-                compiledQuery.parameters
-            )
 
             const fetchedUser = mapFetchedUser(
-                result.rows?.[0] as Record<string, unknown> | undefined
+                result[0] as Record<string, unknown> | undefined
             )
+
             return authenticationCoreLib.AuthenticationCoreLogin.login(
                 typedMail,
                 typedPassword,

package/scripts/extension-wrappers/@tobi2409/authentication-core-db/register.ts

@@ -1,6 +1,6 @@
 import { DbConnection } from '../../db-connection/db-connection-wrapper.ts'
-// @ts-ignore kysely is supplied by the server package in generated projects.
-import { KyselyWrapper } from '../../kysely/kysely-wrapper.ts'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { DrizzleWrapper } from '../../drizzle/drizzle-wrapper.ts'
 import { authenticationCoreLib } from '../../@tobi2409/authentication-core-lib/authentication-core-lib-wrapper.ts'
 import {
     DEFAULT_TABLE_NAME,
@@ -8,7 +8,7 @@ import {
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreKyselyRegister {
+export namespace AuthenticationCoreDrizzleRegister {
     function mapFetchedUser(
         row: Record<string, unknown> | undefined
     ): authenticationCoreLib.FetchedUser | undefined {
@@ -38,92 +38,104 @@ export namespace AuthenticationCoreKyselyRegister {
             typeof authenticationCoreLib.AuthenticationCoreRegister.register
         >[6]
     ): Promise<authenticationCoreLib.FetchedUser> {
-        const db = KyselyWrapper.buildQueryCompiler(
+        // The wrapper only stores the driver name and is very lightweight;
+        // the pool is supplied per query context, so repeated initialization is safe.
+        const drizzleWrapper = new DrizzleWrapper(
             dbConnection.getDriverName()
         )
+        const db = drizzleWrapper.buildQueryBuilder(
+            await dbConnection.getPool()
+        )
+        const users = drizzleWrapper.buildTable(tableName, columns, {
+            uuid: 'uuid',
+            isActive: 'boolean'
+        })
 
-        // 'any' is used instead of 'unknown' because calling pool/client APIs on an unknown type requires
-        // either a type assertion or a separate interface. DbConnection is driver-agnostic, so
-        // the concrete pool/client type (e.g. pg.Pool/PoolClient) is not available here without adding a dependency.
-        const pool = (await dbConnection.getConnection()) as any
-        const transactionConnection = await pool.connect()
+        return db.transaction(async (transactionDb: any) => {
+            const mailExistsRoutine = async (mail: string): Promise<boolean> => {
+                const result = await transactionDb
+                    .select({ mail: users.mail })
+                    .from(users)
+                    .where(DrizzleWrapper.eq(users.mail, mail))
+                    .limit(1)
 
-        const mailExistsRoutine = async (mail: string): Promise<boolean> => {
-            const compiledQuery = db
-                .selectFrom(tableName)
-                .select((eb: any) => [eb.val(1).as('exists')])
-                .where(KyselyWrapper.sql.ref(columns.mail), '=', mail)
-                .limit(1)
-                .compile()
+                return result.length > 0
+            }
 
-            const result = await transactionConnection.query(
-                compiledQuery.sql,
-                compiledQuery.parameters
-            )
+            const dataProcessing = async (
+                identification: string,
+                hashedPassword: string,
+                inputData: Record<string, unknown>
+            ): Promise<authenticationCoreLib.FetchedUser | undefined> => {
+                const userData: Record<string, unknown> = {
+                    [columns.mail]: identification,
+                    [columns.password]: hashedPassword,
+                    [columns.isActive]: false,
+                    ...inputData
+                }
 
-            return (result.rows?.length ?? 0) > 0
-        }
+                const insertUsers = drizzleWrapper.buildTable(
+                    tableName,
+                    Object.fromEntries(
+                        Object.keys({ ...columns, ...userData }).map((column) => [
+                            column,
+                            columns[column as keyof UserColumn] ?? column
+                        ])
+                    ),
+                    { uuid: 'uuid', isActive: 'boolean' }
+                )
 
-        const dataProcessing = async (
-            identification: string,
-            hashedPassword: string,
-            inputData: Record<string, unknown>
-        ): Promise<authenticationCoreLib.FetchedUser | undefined> => {
-            const userData: Record<string, unknown> = {
-                [columns.mail]: identification,
-                [columns.password]: hashedPassword,
-                [columns.isActive]: false,
-                ...inputData
-            }
+                const result = await transactionDb
+                    .insert(insertUsers)
+                    .values(userData)
+                    .returning({
+                        uuid: insertUsers.uuid,
+                        mail: insertUsers.mail,
+                        password: insertUsers.password,
+                        isActive: insertUsers.isActive
+                    })
 
-            const compiledQuery = db
-                .insertInto(tableName)
-                .values(userData as any)
-                .returning([
-                    KyselyWrapper.sql.ref(columns.uuid).as('uuid'),
-                    KyselyWrapper.sql.ref(columns.mail).as('mail'),
-                    KyselyWrapper.sql.ref(columns.password).as('password'),
-                    KyselyWrapper.sql.ref(columns.isActive).as('isActive')
-                ])
-                .compile()
+                return mapFetchedUser(
+                    result[0] as Record<string, unknown> | undefined
+                )
+            }
 
-            const result = await transactionConnection.query(
-                compiledQuery.sql,
-                compiledQuery.parameters
+            return authenticationCoreLib.AuthenticationCoreRegister.register(
+                registrationInputData,
+                mailExistsRoutine,
+                customInputData,
+                dataProcessing,
+                verificationMail,
+                mailTransportConfig,
+                hashOptions
             )
-            return mapFetchedUser(
-                result.rows?.[0] as Record<string, unknown> | undefined
-            )
-        }
+        })
+    }
 
-        try {
-            await transactionConnection.query('BEGIN')
+    export async function activateMail(
+        uuid: string,
+        dbConnection: DbConnection,
+        tableName: string = DEFAULT_TABLE_NAME,
+        columns: UserColumn = DEFAULT_USER_COLUMN
+    ): Promise<void> {
+        // The wrapper only stores the driver name and is very lightweight;
+        // the pool is supplied per query context, so repeated initialization is safe.
+        const drizzleWrapper = new DrizzleWrapper(
+            dbConnection.getDriverName()
+        )
 
-            const registeredUser =
-                await authenticationCoreLib.AuthenticationCoreRegister.register(
-                    registrationInputData,
-                    mailExistsRoutine,
-                    customInputData,
-                    dataProcessing,
-                    verificationMail,
-                    mailTransportConfig,
-                    hashOptions
-                )
+        const db = drizzleWrapper.buildQueryBuilder(
+            await dbConnection.getPool()
+        )
 
-            await transactionConnection.query('COMMIT')
-            return registeredUser
-        } catch (error) {
-            try {
-                await transactionConnection.query('ROLLBACK')
-            } catch {
-                // Ignore rollback errors, original error is more relevant.
-            }
+        const users = drizzleWrapper.buildTable(tableName, columns, {
+            uuid: 'uuid',
+            isActive: 'boolean'
+        })
 
-            throw error
-        } finally {
-            if (typeof transactionConnection.release === 'function') {
-                transactionConnection.release()
-            }
-        }
+        await db
+            .update(users)
+            .set({ [columns.isActive]: true })
+            .where(DrizzleWrapper.eq(users.uuid, uuid))
     }
 }

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

@@ -1,5 +1,9 @@
 type DriverName = 'pg' | 'mysql' | 'sqlite'
 
+import { pgWrapperAccessToken } from './pg-wrapper-access.ts'
+
+export { pgWrapperAccessToken }
+
 interface ConnectionData {
     connectionName?: string
 }
@@ -16,14 +20,15 @@ export class DbConnection {
         return this.driverName
     }
 
-    async getConnection(): Promise<unknown> {
+    async getPool(): Promise<unknown> {
         if (this.driverName === 'pg') {
             if (!this.connectionWrapper) {
                 // @ts-ignore pg-wrapper is supplied by the pg extension in generated projects.
-                const { PgConnectionWrapper } =
+                const createPgConnectionWrapper =
                     await import('../pg/pg-wrapper.ts')
-                this.connectionWrapper = new PgConnectionWrapper(
-                    this.connectionData.connectionName ?? 'default'
+                this.connectionWrapper = createPgConnectionWrapper.default(
+                    this.connectionData.connectionName ?? 'default',
+                    pgWrapperAccessToken
                 )
             }
 

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

@@ -0,0 +1 @@
+export const pgWrapperAccessToken = Symbol('pg-wrapper-access')

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

@@ -0,0 +1,89 @@
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { eq, sql as drizzleSql, type SQL } from 'drizzle-orm'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { drizzle } from 'drizzle-orm/node-postgres'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { boolean as pgBoolean, integer, pgTable, text, uuid as pgUuid } from 'drizzle-orm/pg-core'
+// @ts-ignore drizzle-orm is supplied by the server package in generated projects.
+import { PgDialect } from 'drizzle-orm/pg-core'
+
+type DriverName = 'pg' | 'mysql' | 'sqlite'
+type ColumnType = 'text' | 'boolean' | 'integer' | 'uuid'
+
+export class DrizzleWrapper {
+    static readonly sql = drizzleSql
+    static readonly eq = eq
+
+    // The pool connection belongs to the current query or transaction and can
+    // therefore change between calls. Apart from the driver name, this wrapper
+    // holds no state and is very lightweight, so it can safely be initialized
+    // more than once. buildQueryBuilder receives the appropriate connection.
+    constructor(private readonly driverName: DriverName) {}
+
+    buildQueryBuilder(connection: unknown): any {
+        this.assertPostgresDriver()
+
+        // Creating the Drizzle instance does not execute a query. It only creates
+        // a lightweight executable facade around the supplied pool or transaction
+        // connection; database work starts when a built query is awaited.
+        return drizzle(connection as any)
+    }
+
+    buildTable(
+        tableName: string,
+        columns: Record<string, string>,
+        columnTypes: Record<string, ColumnType> = {}
+    ): any {
+        this.assertPostgresDriver()
+
+        // pgTable only creates lightweight metadata for an existing table; it does
+        // not open a connection, query, create, or migrate anything. Missing tables
+        // or columns fail when the query is executed. Columns default to text unless
+        // a PostgreSQL type is explicitly supplied.
+        return pgTable(
+            tableName,
+            Object.fromEntries(
+                Object.entries(columns).map(([propertyName, columnName]) => [
+                    propertyName,
+                    this.buildColumn(columnName, columnTypes[propertyName])
+                ])
+            ) as any
+        )
+    }
+
+    private buildColumn(columnName: string, columnType: ColumnType = 'text'): any {
+        switch (columnType) {
+            case 'boolean':
+                return pgBoolean(columnName)
+            case 'integer':
+                return integer(columnName)
+            case 'uuid':
+                return pgUuid(columnName)
+            default:
+                return text(columnName)
+        }
+    }
+
+    buildQueryCompiler(): {
+        compile(query: SQL): { sql: string; parameters: unknown[] }
+    } {
+        this.assertPostgresDriver()
+
+        const dialect = new PgDialect()
+        return {
+            compile(query) {
+                const compiledQuery = dialect.sqlToQuery(query)
+                return {
+                    sql: compiledQuery.sql,
+                    parameters: compiledQuery.params
+                }
+            }
+        }
+    }
+
+    private assertPostgresDriver(): void {
+        if (this.driverName !== 'pg') {
+            throw new Error(`Driver is not integrated yet: ${this.driverName}`)
+        }
+    }
+}

package/scripts/extension-wrappers/drizzle/extension.json

@@ -0,0 +1,5 @@
+{
+    "addToServerPackage": true,
+    "packageName": "drizzle-orm",
+    "dependencies": ["db-connection"]
+}

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

@@ -8,8 +8,9 @@ import path from 'path'
 import { Pool } from 'pg'
 // @ts-ignore node types are supplied by the server package in generated projects.
 import { fileURLToPath } from 'url'
+import { pgWrapperAccessToken } from '../db-connection/pg-wrapper-access.ts'
 
-export class PgConnectionWrapper {
+class PgConnectionWrapper {
     private pool: Pool | null = null
     private pgEnv: Record<string, string> = {}
     private pgEnvLoaded: boolean = false
@@ -75,3 +76,15 @@ export class PgConnectionWrapper {
         this.pool = null
     }
 }
+
+export default function createPgConnectionWrapper(
+    connectionName: string = 'default',
+    accessToken?: symbol
+): PgConnectionWrapper {
+    // only accessible by DbConnection
+    if (accessToken !== pgWrapperAccessToken) {
+        throw new Error('PgConnectionWrapper can only be created by DbConnection')
+    }
+
+    return new PgConnectionWrapper(connectionName)
+}

package/scripts/extension-wrappers/sql-template-tag/extension.json

@@ -1,3 +1,4 @@
 {
-    "addToServerPackage": true
+    "addToServerPackage": true,
+    "dependencies": ["db-connection"]
 }

package/scripts/fullsty-server-pkg.js

@@ -42,5 +42,6 @@ try {
     console.error(
         `\n❌ ${error instanceof Error ? error.message : String(error)}`
     )
+    
     process.exit(1)
 }

package/scripts/project-frame/client-package.json

@@ -3,7 +3,7 @@
     "private": true,
     "type": "module",
     "dependencies": {
-        "@tobi2409/mvvm-monster": "^0.9.13",
-        "@tobi2409/layout": "^0.5.0"
+        "@tobi2409/mvvm-monster": "0.9.13",
+        "@tobi2409/layout": "0.5.0"
     }
 }

package/scripts/project-frame/package.json

@@ -12,6 +12,6 @@
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "devDependencies": {
-        "@tobi2409/proc2rest": "^0.5.0"
+        "@tobi2409/proc2rest": "0.8.2"
     }
 }

package/scripts/project-frame/server-package.json

@@ -6,18 +6,18 @@
         "start": "tsx routes.generated.ts"
     },
     "dependencies": {
-        "@msgpack/msgpack": "^3.1.3",
-        "cors": "^2.8.6",
-        "dotenv": "^17.4.2",
-        "express": "^5.2.1",
-        "express-rate-limit": "^8.3.1",
-        "helmet": "^8.3.0"
+        "@msgpack/msgpack": "3.1.3",
+        "cors": "2.8.6",
+        "dotenv": "17.4.2",
+        "express": "5.2.1",
+        "express-rate-limit": "8.7.0",
+        "helmet": "8.3.0"
     },
     "devDependencies": {
-        "@types/cors": "^2.8.17",
-        "@types/express": "^5.0.5",
-        "@types/node": "^24.10.1",
-        "tsx": "^4.20.6",
-        "typescript": "^5.9.3"
+        "@types/cors": "2.8.19",
+        "@types/express": "5.0.6",
+        "@types/node": "26.5.0",
+        "tsx": "4.23.13",
+        "typescript": "7.0.2"
     }
 }

package/scripts/project-frame/src/client/index.html

@@ -8,7 +8,7 @@
         <script type="importmap">
             {
                 "imports": {
-                    "template-engine/": "./node_modules/@tobi2409/template-engine/src/"
+                    "mvvm-monster/": "./node_modules/@tobi2409/mvvm-monster/src/"
                 }
             }
         </script>

package/scripts/project-frame/src/client/index.js

@@ -1,6 +1,6 @@
 // @server-import server.ts
 
-import TemplateEngine from 'template-engine/template-engine.js'
+import TemplateEngine from 'mvvm-monster/template-engine.js'
 
 const data = TemplateEngine.reactive(
     {

package/scripts/shared/server-package-utils.js

@@ -21,28 +21,46 @@ export function handleAdd(projectDir, scriptDir, serverDir, packageNames) {
         json.dependencies = {}
     }
 
-    for (const packageName of packageNames) {
+    const processedPackages = new Set()
+
+    function addPackage(packageName) {
+        if (processedPackages.has(packageName)) {
+            return
+        }
+
+        processedPackages.add(packageName)
         const wrapperDir = wrapperDirFromPackage(scriptDir, packageName)
         const targetWrapperDir = path.join(serverDir, packageName)
         const wrapperExists = fs.existsSync(wrapperDir)
 
         if (!wrapperExists) {
             json.dependencies[packageName] = 'latest'
-            continue
+            return
         }
 
-        if (shouldAddToServerPackage(wrapperDir)) {
-            json.dependencies[packageName] = 'latest'
+        const extensionConfig = readJson(wrapperDir, EXTENSION_CONFIG_FILE)
+        for (const dependency of extensionConfig.dependencies ?? []) {
+            addPackage(dependency)
+        }
+
+        if (extensionConfig.addToServerPackage) {
+            const serverPackageName = extensionConfig.packageName ?? packageName
+            json.dependencies[serverPackageName] = 'latest'
         }
 
         copyDirectory(wrapperDir, targetWrapperDir, {
             excludedNames: [EXTENSION_CONFIG_FILE]
         })
+
         console.log(
             `\n✅ Copied wrapper for ${packageName} to src/server/${packageName}`
         )
     }
 
+    for (const packageName of packageNames) {
+        addPackage(packageName)
+    }
+
     writeJson(projectDir, 'server-package.json', json)
 }
 

package/scripts/extension-wrappers/kysely/extension.json

@@ -1,3 +0,0 @@
-{
-    "addToServerPackage": true
-}

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

@@ -1,31 +0,0 @@
-// @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}`)
-    }
-}