@tobi2409/fullsty 0.8.3 → 0.8.4

package/README.md

@@ -25,7 +25,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 drizzle
+fullsty-server-pkg add @tobi2409/sql-query-builder
 ```
 
 ## 1) Create a project
@@ -70,7 +70,7 @@ Run it from the project root, for example:
 
 ```bash
 fullsty-server-pkg add pg
-fullsty-server-pkg add drizzle
+fullsty-server-pkg add @tobi2409/sql-query-builder
 fullsty-server-pkg remove pg
 ```
 
@@ -94,7 +94,7 @@ command and `npm run generate` after changing an extension or its dependencies.
 
 After `fullsty-server-pkg 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 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.
+`fullsty-server-pkg add @tobi2409/sql-query-builder` adds the SQL query builder to the generated server dependencies. For PostgreSQL pooling and env handling, add `pg` separately.
 
 ## 5) Start the generated server
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tobi2409/fullsty",
-    "version": "0.8.3",
+    "version": "0.8.4",
     "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,14 +1,14 @@
+import SQLQueryBuilder from '@tobi2409/sql-query-builder'
 import { DbConnection } from '../../db-connection/db-connection-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,
     DEFAULT_USER_COLUMN,
+    quoteIdentifier,
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreDrizzleCurrentUser {
+export namespace AuthenticationCoreDbCurrentUser {
     export async function getCurrentUser(
         token: string,
         jwtKey: Parameters<
@@ -22,31 +22,23 @@ export namespace AuthenticationCoreDrizzleCurrentUser {
         >[3] = {}
     ): Promise<string> {
         try {
-            // 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 connection = (await dbConnection.getPool()) as any
 
             const isActiveCallback = async (uuid: string): Promise<boolean> => {
-                const result = await db
-                    .select({ isActive: users.isActive })
-                    .from(users)
-                    .where(DrizzleWrapper.eq(users.uuid, uuid))
+                const query = new SQLQueryBuilder(dbConnection.getDriverName())
+                    .select([`${quoteIdentifier(columns.isActive)} AS "isActive"`])
+                    .from(quoteIdentifier(tableName))
+                    .where(`${quoteIdentifier(columns.uuid)} = ?`, [uuid])
                     .limit(1)
+                    .toSQL()
+                    
+                const result = await connection.query(query.text, query.values)
 
-                if (!result[0]) {
+                if (!result.rows[0]) {
                     return false
                 }
 
-                return Boolean(result[0].isActive)
+                return Boolean(result.rows[0].isActive)
             }
 
             return authenticationCoreLib.AuthenticationCoreCurrentUser.getCurrentUser(

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

@@ -2,7 +2,7 @@
     "addToServerPackage": false,
     "dependencies": [
         "db-connection",
-        "drizzle",
+        "@tobi2409/sql-query-builder",
         "@tobi2409/authentication-core-lib"
     ]
 }

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

@@ -1,14 +1,14 @@
+import SQLQueryBuilder from '@tobi2409/sql-query-builder'
 import { DbConnection } from '../../db-connection/db-connection-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,
     DEFAULT_USER_COLUMN,
+    quoteIdentifier,
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreDrizzleLogin {
+export namespace AuthenticationCoreDbLogin {
     function mapFetchedUser(
         row: Record<string, unknown> | undefined
     ): authenticationCoreLib.FetchedUser | undefined {
@@ -38,32 +38,23 @@ export namespace AuthenticationCoreDrizzleLogin {
         >[4] = {}
     ): Promise<string> {
         try {
-            // 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 result = await db
-                .select({
-                    uuid: users.uuid,
-                    mail: users.mail,
-                    password: users.password,
-                    isActive: users.isActive
-                })
-                .from(users)
-                .where(DrizzleWrapper.eq(users.mail, typedMail))
+            const query = new SQLQueryBuilder(dbConnection.getDriverName())
+                .select([
+                    `${quoteIdentifier(columns.uuid)} AS "uuid"`,
+                    `${quoteIdentifier(columns.mail)} AS "mail"`,
+                    `${quoteIdentifier(columns.password)} AS "password"`,
+                    `${quoteIdentifier(columns.isActive)} AS "isActive"`
+                ])
+                .from(quoteIdentifier(tableName))
+                .where(`${quoteIdentifier(columns.mail)} = ?`, [typedMail])
                 .limit(1)
+                .toSQL()
+                
+            const connection = (await dbConnection.getPool()) as any
+            const result = await connection.query(query.text, query.values)
 
             const fetchedUser = mapFetchedUser(
-                result[0] as Record<string, unknown> | undefined
+                result.rows[0] as Record<string, unknown> | undefined
             )
 
             return authenticationCoreLib.AuthenticationCoreLogin.login(

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

@@ -1,14 +1,14 @@
+import SQLQueryBuilder from '@tobi2409/sql-query-builder'
 import { DbConnection } from '../../db-connection/db-connection-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,
     DEFAULT_USER_COLUMN,
+    quoteIdentifier,
     UserColumn
 } from './shared.ts'
 
-export namespace AuthenticationCoreDrizzleRegister {
+export namespace AuthenticationCoreDbRegister {
     function mapFetchedUser(
         row: Record<string, unknown> | undefined
     ): authenticationCoreLib.FetchedUser | undefined {
@@ -38,28 +38,23 @@ export namespace AuthenticationCoreDrizzleRegister {
             typeof authenticationCoreLib.AuthenticationCoreRegister.register
         >[6]
     ): Promise<authenticationCoreLib.FetchedUser> {
-        // 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 pool = (await dbConnection.getPool()) as any
+        const transaction = await pool.connect()
+
+        try {
+            await transaction.query('BEGIN')
 
-        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))
+                const query = new SQLQueryBuilder(dbConnection.getDriverName())
+                    .select([quoteIdentifier(columns.mail)])
+                    .from(quoteIdentifier(tableName))
+                    .where(`${quoteIdentifier(columns.mail)} = ?`, [mail])
                     .limit(1)
+                    .toSQL()
+
+                const result = await transaction.query(query.text, query.values)
 
-                return result.length > 0
+                return result.rows.length > 0
             }
 
             const dataProcessing = async (
@@ -74,33 +69,28 @@ export namespace AuthenticationCoreDrizzleRegister {
                     ...inputData
                 }
 
-                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 query = new SQLQueryBuilder(dbConnection.getDriverName())
+                    .insertInto(
+                        quoteIdentifier(tableName),
+                        Object.keys(userData).map(quoteIdentifier)
+                    )
+                    .values(Object.values(userData))
+                    .returning([
+                        `${quoteIdentifier(columns.uuid)} AS "uuid"`,
+                        `${quoteIdentifier(columns.mail)} AS "mail"`,
+                        `${quoteIdentifier(columns.password)} AS "password"`,
+                        `${quoteIdentifier(columns.isActive)} AS "isActive"`
+                    ])
+                    .toSQL()
 
-                const result = await transactionDb
-                    .insert(insertUsers)
-                    .values(userData)
-                    .returning({
-                        uuid: insertUsers.uuid,
-                        mail: insertUsers.mail,
-                        password: insertUsers.password,
-                        isActive: insertUsers.isActive
-                    })
+                const result = await transaction.query(query.text, query.values)
 
                 return mapFetchedUser(
-                    result[0] as Record<string, unknown> | undefined
+                    result.rows[0] as Record<string, unknown> | undefined
                 )
             }
 
-            return authenticationCoreLib.AuthenticationCoreRegister.register(
+            const registeredUser = await authenticationCoreLib.AuthenticationCoreRegister.register(
                 registrationInputData,
                 mailExistsRoutine,
                 customInputData,
@@ -109,7 +99,14 @@ export namespace AuthenticationCoreDrizzleRegister {
                 mailTransportConfig,
                 hashOptions
             )
-        })
+            await transaction.query('COMMIT')
+            return registeredUser
+        } catch (error) {
+            await transaction.query('ROLLBACK')
+            throw error
+        } finally {
+            transaction.release()
+        }
     }
 
     export async function activateMail(
@@ -118,24 +115,13 @@ export namespace AuthenticationCoreDrizzleRegister {
         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 db = drizzleWrapper.buildQueryBuilder(
-            await dbConnection.getPool()
-        )
-
-        const users = drizzleWrapper.buildTable(tableName, columns, {
-            uuid: 'uuid',
-            isActive: 'boolean'
-        })
-
-        await db
-            .update(users)
-            .set({ [columns.isActive]: true })
-            .where(DrizzleWrapper.eq(users.uuid, uuid))
+        const query = new SQLQueryBuilder(dbConnection.getDriverName())
+            .update(quoteIdentifier(tableName))
+            .setRaw(`${quoteIdentifier(columns.isActive)} = ?`, [true])
+            .where(`${quoteIdentifier(columns.uuid)} = ?`, [uuid])
+            .toSQL()
+            
+        const connection = (await dbConnection.getPool()) as any
+        await connection.query(query.text, query.values)
     }
 }

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

@@ -13,3 +13,10 @@ export const DEFAULT_USER_COLUMN: UserColumn = {
     password: 'password',
     isActive: 'isActive'
 }
+
+export function quoteIdentifier(identifier: string): string {
+    return identifier
+        .split('.')
+        .map((part) => `"${part.replaceAll('"', '""')}"`)
+        .join('.')
+}

package/scripts/extension-wrappers/@tobi2409/sql-query-builder/extension.json

@@ -0,0 +1,4 @@
+{
+    "addToServerPackage": true,
+    "dependencies": []
+}

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

@@ -1,89 +0,0 @@
-// @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

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