@fragno-dev/create 0.1.3 → 0.1.5

package/templates/optional/database/index.ts

@@ -1,14 +1,10 @@
+import { defineFragment, defineRoutes, instantiate } from "@fragno-dev/core";
+import { createClientBuilder, type FragnoPublicClientConfig } from "@fragno-dev/core/client";
 import {
-  defineRoute,
-  defineRoutes,
-  createFragment,
-  type FragnoPublicClientConfig,
-} from "@fragno-dev/core";
-import { createClientBuilder } from "@fragno-dev/core/client";
-import {
-  defineFragmentWithDatabase,
+  withDatabase,
   type FragnoPublicConfigWithDatabase,
-} from "@fragno-dev/db/fragment";
+  ExponentialBackoffRetryPolicy,
+} from "@fragno-dev/db";
 import type { TableToInsertValues } from "@fragno-dev/db/query";
 import { noteSchema } from "./schema";
 
@@ -19,35 +15,125 @@ import { z } from "zod";
 
 export interface ExampleConfig {
   // Add any server-side configuration here if needed
+  onNoteCreated?: (nonce: string, payload: { noteId: string; userId: string }) => Promise<void>;
 }
 
-type ExampleServices = {
-  createNote: (note: TableToInsertValues<typeof noteSchema.tables.note>) => Promise<{
-    id: string;
-    content: string;
-    userId: string;
-    createdAt: Date;
-  }>;
-  getNotes: () => Promise<
-    Array<{
-      id: string;
-      content: string;
-      userId: string;
-      createdAt: Date;
-    }>
-  >;
-  getNotesByUser: (userId: string) => Promise<
-    Array<{
-      id: string;
-      content: string;
-      userId: string;
-      createdAt: Date;
-    }>
-  >;
-};
-
-const exampleRoutesFactory = defineRoutes<ExampleConfig, {}, ExampleServices>().create(
-  ({ services }) => {
+const exampleFragmentDefinition = defineFragment<ExampleConfig>("example-fragment")
+  .extend(withDatabase(noteSchema))
+  .provideHooks(({ defineHook, config }) => ({
+    onNoteCreated: defineHook(async function (payload: { noteId: string; userId: string }) {
+      // Hook runs after transaction commits, with retries on failure
+      // Use this.nonce for idempotency (available via this context)
+      await config.onNoteCreated?.(this.nonce, payload);
+    }),
+  }))
+  .providesBaseService(({ defineService }) => {
+    return defineService({
+      createNote: async function (
+        note: Omit<TableToInsertValues<typeof noteSchema.tables.note>, "userId"> & {
+          userId: string;
+        },
+      ) {
+        const uow = this.uow(noteSchema);
+
+        // Find user first to get FragnoId for reference
+        const userUow = uow.findFirst("user", (b) =>
+          b.whereIndex("idx_user_email", (eb) => eb("email", "=", note.userId)),
+        );
+        const [user] = await userUow.retrievalPhase;
+
+        if (!user) {
+          throw new Error("User not found");
+        }
+
+        // Create note with reference to user
+        const noteId = uow.create("note", {
+          content: note.content,
+          userId: user.id,
+        });
+
+        // Trigger durable hook (recorded in transaction, executed after commit)
+        uow.triggerHook("onNoteCreated", {
+          noteId: noteId.valueOf(),
+          userId: user.id.valueOf(),
+        });
+
+        // Wait for handler to execute mutation phase
+        await uow.mutationPhase;
+
+        return {
+          id: noteId.valueOf(),
+          content: note.content,
+          userId: user.id.valueOf(),
+          createdAt: new Date(),
+        };
+      },
+      getNotes: async function () {
+        const uow = this.uow(noteSchema).find("note", (b) =>
+          b.whereIndex("primary").join((j) => j.author()),
+        );
+        const [notes] = await uow.retrievalPhase;
+        return notes;
+      },
+      getNotesByUser: async function (userEmail: string) {
+        const uow = this.uow(noteSchema);
+
+        // First find the user by email
+        const userUow = uow.findFirst("user", (b) =>
+          b.whereIndex("idx_user_email", (eb) => eb("email", "=", userEmail)),
+        );
+        const [user] = await userUow.retrievalPhase;
+
+        if (!user) {
+          return [];
+        }
+
+        // Then find notes by the user's FragnoId
+        // Note: userId is a reference column, FragnoId works directly in whereIndex
+        const notesUow = uow.find("note", (b) =>
+          b.whereIndex("idx_note_user", (eb) => eb("userId", "=", user.id)).join((j) => j.author()),
+        );
+        const [notes] = await notesUow.retrievalPhase;
+        return notes;
+      },
+      updateNote: async function (noteId: string, content: string) {
+        const uow = this.uow(noteSchema);
+
+        // Find note first to get FragnoId for optimistic concurrency control
+        // Join with author to get user information
+        const noteUow = uow.findFirst("note", (b) =>
+          b.whereIndex("primary", (eb) => eb("id", "=", noteId)).join((j) => j.author()),
+        );
+        const [note] = await noteUow.retrievalPhase;
+
+        if (!note) {
+          throw new Error("Note not found");
+        }
+
+        // Update with optimistic concurrency control (.check())
+        uow.update("note", note.id, (b) => b.set({ content }).check());
+
+        // Wait for handler to execute mutation phase
+        // On optimistic conflict, handler will retry the whole transaction
+        await uow.mutationPhase;
+
+        if (!note.author) {
+          throw new Error("Note author not found");
+        }
+
+        return {
+          id: note.id.valueOf(),
+          content,
+          userId: note.author.id.valueOf(),
+          createdAt: note.createdAt,
+        };
+      },
+    });
+  })
+  .build();
+
+const exampleRoutesFactory = defineRoutes(exampleFragmentDefinition).create(
+  ({ services, defineRoute }) => {
     return [
       defineRoute({
         method: "GET",
@@ -58,26 +144,84 @@ const exampleRoutesFactory = defineRoutes<ExampleConfig, {}, ExampleServices>().
             id: z.string(),
             content: z.string(),
             userId: z.string(),
+            userName: z.string(),
             createdAt: z.date(),
           }),
         ),
-        handler: async ({ query }, { json }) => {
-          const userId = query.get("userId");
+        handler: async function ({ query }, { json }) {
+          const userEmail = query.get("userId"); // Using userId param name for backward compatibility
+
+          const result = await this.uow(async ({ executeRetrieve }) => {
+            const notesPromise = userEmail
+              ? services.getNotesByUser(userEmail)
+              : services.getNotes();
+
+            // Execute all reads scheduled by services
+            await executeRetrieve();
+
+            return notesPromise;
+          });
 
-          if (userId) {
-            const notes = await services.getNotesByUser(userId);
-            return json(notes);
-          }
+          const notes = await result;
 
-          const notes = await services.getNotes();
-          return json(notes);
+          return json(
+            notes
+              .filter((note) => note.author !== null)
+              .map((note) => ({
+                id: note.id.valueOf(),
+                content: note.content,
+                userId: note.author!.id.valueOf(),
+                userName: note.author!.name,
+                createdAt: note.createdAt,
+              })),
+          );
         },
       }),
 
       defineRoute({
         method: "POST",
         path: "/notes",
-        inputSchema: z.object({ content: z.string(), userId: z.string() }),
+        inputSchema: z.object({ content: z.string(), userEmail: z.string() }),
+        outputSchema: z.object({
+          id: z.string(),
+          content: z.string(),
+          userId: z.string(),
+          createdAt: z.date(),
+        }),
+        errorCodes: [],
+        handler: async function ({ input }, { json }) {
+          const { content, userEmail } = await input.valid();
+
+          // Handler controls transaction execution with retry policy
+          const result = await this.uow(
+            async ({ executeMutate }) => {
+              const notePromise = services.createNote({ content, userId: userEmail });
+
+              // Execute retrieval (if needed) and mutation atomically
+              // On optimistic conflict, this whole callback retries
+              await executeMutate();
+
+              return notePromise;
+            },
+            {
+              // Retry policy for optimistic concurrency conflicts
+              retryPolicy: new ExponentialBackoffRetryPolicy({
+                maxRetries: 5,
+                initialDelayMs: 10,
+                maxDelayMs: 250,
+              }),
+            },
+          );
+
+          const note = await result;
+          return json(note);
+        },
+      }),
+
+      defineRoute({
+        method: "PATCH",
+        path: "/notes/:noteId",
+        inputSchema: z.object({ content: z.string() }),
         outputSchema: z.object({
           id: z.string(),
           content: z.string(),
@@ -85,10 +229,31 @@ const exampleRoutesFactory = defineRoutes<ExampleConfig, {}, ExampleServices>().
           createdAt: z.date(),
         }),
         errorCodes: [],
-        handler: async ({ input }, { json }) => {
-          const { content, userId } = await input.valid();
+        handler: async function ({ input, pathParams }, { json }) {
+          const { content } = await input.valid();
+          const noteId = pathParams.noteId;
+
+          // Handler controls transaction with optimistic concurrency control
+          const result = await this.uow(
+            async ({ executeMutate }) => {
+              const notePromise = services.updateNote(noteId, content);
+
+              // Execute with optimistic concurrency control
+              // If note was modified, whole transaction retries
+              await executeMutate();
+
+              return notePromise;
+            },
+            {
+              retryPolicy: new ExponentialBackoffRetryPolicy({
+                maxRetries: 5,
+                initialDelayMs: 10,
+                maxDelayMs: 250,
+              }),
+            },
+          );
 
-          const note = await services.createNote({ content, userId });
+          const note = await result;
           return json(note);
         },
       }),
@@ -96,34 +261,15 @@ const exampleRoutesFactory = defineRoutes<ExampleConfig, {}, ExampleServices>().
   },
 );
 
-const exampleFragmentDefinition = defineFragmentWithDatabase<ExampleConfig>("example-fragment")
-  .withDatabase(noteSchema)
-  .providesService(({ db }) => {
-    return {
-      createNote: async (note: TableToInsertValues<typeof noteSchema.tables.note>) => {
-        const id = await db.create("note", note);
-        return {
-          ...note,
-          id: id.toJSON(),
-          createdAt: note.createdAt ?? new Date(),
-        };
-      },
-      getNotes: () => {
-        return db.find("note", (b) => b);
-      },
-      getNotesByUser: (userId: string) => {
-        return db.find("note", (b) =>
-          b.whereIndex("idx_note_user", (eb) => eb("userId", "=", userId)),
-        );
-      },
-    };
-  });
-
 export function createExampleFragment(
   config: ExampleConfig = {},
-  fragnoConfig: FragnoPublicConfigWithDatabase,
+  options: FragnoPublicConfigWithDatabase,
 ) {
-  return createFragment(exampleFragmentDefinition, config, [exampleRoutesFactory], fragnoConfig);
+  return instantiate(exampleFragmentDefinition)
+    .withConfig(config)
+    .withRoutes([exampleRoutesFactory])
+    .withOptions(options)
+    .build();
 }
 
 export function createExampleFragmentClients(fragnoConfig: FragnoPublicClientConfig) {
@@ -134,4 +280,4 @@ export function createExampleFragmentClients(fragnoConfig: FragnoPublicClientCon
     useCreateNote: b.createMutator("POST", "/notes"),
   };
 }
-export type { FragnoRouteConfig } from "@fragno-dev/core/api";
+export type { FragnoRouteConfig } from "@fragno-dev/core";

package/templates/optional/database/schema.ts

@@ -1,15 +1,28 @@
-import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { column, idColumn, referenceColumn, schema } from "@fragno-dev/db/schema";
 
 export const noteSchema = schema((s) => {
-  return s.addTable("note", (t) => {
-    return t
-      .addColumn("id", idColumn())
-      .addColumn("content", column("string"))
-      .addColumn("userId", column("string"))
-      .addColumn(
-        "createdAt",
-        column("timestamp").defaultTo((b) => b.now()),
-      )
-      .createIndex("idx_note_user", ["userId"]);
-  });
+  return s
+    .addTable("user", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("email", column("string"))
+        .createIndex("idx_user_email", ["email"], { unique: true });
+    })
+    .addTable("note", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("content", column("string"))
+        .addColumn("userId", referenceColumn())
+        .addColumn(
+          "createdAt",
+          column("timestamp").defaultTo((b) => b.now()),
+        )
+        .createIndex("idx_note_user", ["userId"]);
+    })
+    .addReference("author", {
+      type: "one",
+      from: { table: "note", column: "userId" },
+      to: { table: "user", column: "id" },
+    });
 });