feat: FINALLY WORKING NEW GEN PROCEDURE

src/server/api/routers/projects/service/index.ts

@@ -16,6 +16,9 @@ import {
 } from "./update";
 import { ServiceSource } from "~/server/db/types";
 import { SQLiteSyncDialect } from "drizzle-orm/sqlite-core";
+import { uuidv7 } from "uuidv7";
+import logger from "~/server/utils/logger";
+import { type Database } from "better-sqlite3";
 
 export const serviceRouter = createTRPCRouter({
   containers: getServiceContainers,
@@ -60,47 +63,64 @@ export const serviceRouter = createTRPCRouter({
     .mutation(async ({ ctx, input }) => {
       // create a generation for the service
       const trxResult = await ctx.db.transaction(async (trx) => {
-        // create initial generation
+        // @ts-expect-error using drizzle-orm doesnt work, keep getting foreign key constraint error after the first insert despite it being deferred
-        const [generation] = await trx
+        const db: Database = trx.session.client;
-          .insert(serviceGeneration)
-          .values({
-            serviceId: "",
-            source: ServiceSource.Docker,
-            dockerImage: "traefik/whoami",
-          })
-          .returning({
-            id: serviceGeneration.id,
-          });
 
-        assert(generation?.id, "Expected generation data to be returned");
+        db.pragma(`defer_foreign_keys = ON`);
+
+        const generationId = uuidv7();
+        const serviceId = uuidv7();
+
+        // create initial generation
+        const dialect = new SQLiteSyncDialect();
+        const createGenerationQuery = dialect.sqlToQuery(
+          trx
+            .insert(serviceGeneration)
+            .values({
+              id: generationId,
+              serviceId: serviceId,
+              source: ServiceSource.Docker,
+              dockerImage: "traefik/whoami",
+            })
+            .getSQL(),
+        );
+
+        const genCreateResult = db
+          .prepare(createGenerationQuery.sql)
+          .run(...createGenerationQuery.params);
+
+        logger.debug(
+          "inserted generation",
+          createGenerationQuery.sql,
+          genCreateResult,
+        );
 
         // create the service
-        const [data] = await trx
+        const createServiceQuery = dialect.sqlToQuery(
-          .insert(service)
+          trx
-          .values({
+            .insert(service)
-            name: input.name,
+            .values({
-            projectId: ctx.project.getData().id,
+              id: serviceId,
-            latestGenerationId: generation.id,
+              name: input.name,
-            redeploySecret: randomBytes(env.REDEPLOY_SECRET_BYTES).toString(
+              projectId: ctx.project.getData().id,
-              "hex",
+              latestGenerationId: generationId,
-            ),
+              redeploySecret: randomBytes(env.REDEPLOY_SECRET_BYTES).toString(
-          })
+                "hex",
-          .returning({
+              ),
-            id: serviceGeneration.id,
+            })
-          });
+            .returning({
+              id: serviceGeneration.id,
+            })
+            .getSQL(),
+        );
 
-        assert(data?.id, "Expected service data to be returned");
+        const createResult = db
+          .prepare(createServiceQuery.sql)
+          .run(...createServiceQuery.params);
 
-        // update the service with the generation id
+        logger.debug("inserted service", createServiceQuery.sql, createResult);
-        await trx
-          .update(serviceGeneration)
-          .set({
-            serviceId: data.id,
-          })
-          .where(eq(service.id, data.id))
-          .execute();
 
-        return data.id;
+        return serviceId;
       });
 
       return trxResult;

src/server/db/index.ts

@@ -48,6 +48,7 @@ function createDatabaseInstance() {
 
   // enable WAL mode
   sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("defer_foreign_keys = true");
 
   // load uuidv7 extension
   // built from https://github.com/craigpastro/sqlite-uuidv7