@fragno-dev/create 0.1.5 → 0.1.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fragno-dev/create",
   "description": "A library for creating Fragno fragments",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "exports": {
     ".": {
       "development": "./src/index.ts",
@@ -14,10 +14,10 @@
   "types": "./dist/index.d.ts",
   "type": "module",
   "dependencies": {
-    "zod": "^4.1.12"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@types/node": "^22",
+    "@types/node": "^22.19.7",
     "@vitest/coverage-istanbul": "^3.2.4",
     "vitest": "^3.2.4",
     "@fragno-private/typescript-config": "0.0.1",

package/src/package-json.ts

@@ -1,18 +1,18 @@
 import type { BuildTools } from "./index";
 
-const fragnoCoreVersion = "0.1.11";
-const fragnoDbVersion = "0.2.0";
-const unpluginFragnoVersion = "0.0.7";
-const fragnoCliVersion = "0.1.21";
+const fragnoCoreVersion = "0.2.0";
+const fragnoDbVersion = "0.3.0";
+const unpluginFragnoVersion = "0.0.8";
+const fragnoCliVersion = "0.2.0";
 
 export const basePkg: Record<string, unknown> = {
   dependencies: {
     "@fragno-dev/core": fragnoCoreVersion,
-    "@standard-schema/spec": "^1.0.0",
-    zod: "^4.0.5",
+    "@standard-schema/spec": "^1.1.0",
+    zod: "^4.3.6",
   },
   devDependencies: {
-    "@types/node": "^24",
+    "@types/node": "^25.2.2",
     "@fragno-dev/cli": fragnoCliVersion,
     "@fragno-dev/unplugin-fragno": unpluginFragnoVersion,
   },
@@ -38,7 +38,7 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   none: {},
   tsdown: {
     devDependencies: {
-      tsdown: "^0.12.0",
+      tsdown: "^0.20.3",
     },
     scripts: {
       build: "tsdown",
@@ -46,7 +46,7 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   },
   esbuild: {
     devDependencies: {
-      esbuild: "^0.25.12",
+      esbuild: "^0.27.3",
     },
     scripts: {
       build: "./esbuild.config.js",
@@ -54,7 +54,7 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   },
   vite: {
     devDependencies: {
-      vite: "^6.3.5",
+      vite: "^7.3.1",
     },
     scripts: {
       build: "vite build",
@@ -62,10 +62,10 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   },
   rollup: {
     devDependencies: {
-      "@rollup/plugin-node-resolve": "^16.0.2",
-      "@rollup/plugin-typescript": "^12.1.4",
+      "@rollup/plugin-node-resolve": "^16.0.3",
+      "@rollup/plugin-typescript": "^12.3.0",
       tslib: "^2.8.1",
-      rollup: "^4.41.0",
+      rollup: "^4.57.1",
     },
     scripts: {
       build: "rollup -c",
@@ -73,9 +73,9 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   },
   webpack: {
     devDependencies: {
-      webpack: "^5.99.9",
+      webpack: "^5.105.0",
       "webpack-cli": "^6.0.1",
-      "ts-loader": "^9.5.1",
+      "ts-loader": "^9.5.4",
     },
     scripts: {
       build: "webpack",
@@ -83,8 +83,8 @@ export const buildToolPkg: Record<BuildTools, Record<string, unknown>> = {
   },
   rspack: {
     devDependencies: {
-      "@rspack/core": "^1.6.1",
-      "@rspack/cli": "^1.6.1",
+      "@rspack/core": "^1.7.5",
+      "@rspack/cli": "^1.7.5",
     },
     scripts: {
       build: "rspack build",

package/templates/optional/agent/AGENTS.md

@@ -133,7 +133,7 @@ Database schemas are defined in a separate `schema.ts` file using the Fragno sch
 ```typescript
 import { column, idColumn, referenceColumn, schema } from "@fragno-dev/db/schema";
 
-export const noteSchema = schema((s) => {
+export const noteSchema = schema("example-fragment", (s) => {
   return s
     .addTable("users", (t) => {
       return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -201,32 +201,43 @@ const fragmentDef = defineFragmentWithDatabase<Config>("my-fragment")
 - `orm.delete(table, id)` - Delete a row by ID
 - `.whereIndex(indexName, condition)` - Use indexes for efficient queries
 
-### Transactions (Unit of Work)
+### Transactions (handlerTx + serviceTx)
 
-Two-phase pattern for atomic operations (optimistic concurrency control):
+Two-phase pattern for atomic operations (optimistic concurrency control) using handler-owned
+transactions:
 
 ```typescript
-// Phase 1: Retrieve with version tracking
-const uow = orm
-  .createUnitOfWork()
-  .find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userId)))
-  .find("accounts", (b) => b.whereIndex("idx_user", (eb) => eb("userId", "=", userId)));
-const [users, accounts] = await uow.executeRetrieve();
-
-// Phase 2: Mutate atomically
-uow.update("users", users[0].id, (b) => b.set({ lastLogin: new Date() }).check());
-uow.update("accounts", accounts[0].id, (b) =>
-  b.set({ balance: accounts[0].balance + 100 }).check(),
-);
-
-const { success } = await uow.executeMutations();
-if (!success) {
-  /* Version conflict - retry */
+// Route handler - owns the transaction boundary
+const [result] = await this.handlerTx()
+  .withServiceCalls(() => [services.transferFunds({ userId, amount })])
+  .execute();
+
+// Service - defines the unit of work
+transferFunds: function ({ userId, amount }: { userId: string; amount: number }) {
+  return this.serviceTx(mySchema)
+    .retrieve((uow) =>
+      uow
+        .findFirst("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userId)))
+        .findFirst("accounts", (b) => b.whereIndex("idx_user", (eb) => eb("userId", "=", userId))),
+    )
+    .mutate(({ uow, retrieveResult: [user, account] }) => {
+      if (!user || !account) {
+        return { ok: false as const };
+      }
+
+      uow.update("users", user.id, (b) => b.set({ lastLogin: new Date() }).check());
+      uow.update("accounts", account.id, (b) =>
+        b.set({ balance: account.balance + amount }).check(),
+      );
+
+      return { ok: true as const };
+    })
+    .build();
 }
 ```
 
-**Notes**: `.check()` enables optimistic concurrency control; requires `FragnoId` objects (not
-string IDs); use `uow.getCreatedIds()` for new record IDs
+**Notes**: `.check()` enables optimistic concurrency control and requires `FragnoId` objects (not
+string IDs).
 
 ## Strategies for Building Fragments
 

package/templates/optional/builder/tsdown.config.ts

@@ -14,15 +14,18 @@ export default defineConfig([
       "./src/client/vue.ts",
     ],
     dts: true,
+    failOnWarn: true,
     platform: "browser",
     outDir: "./dist/browser",
     plugins: [unpluginFragno({ platform: "browser" })],
     noExternal: [/^@fragno-dev\/core\//],
+    inlineOnly: [/^@fragno-dev\/core/, /^nanostores$/, /^@nanostores\//, /^nanoevents$/],
   },
   {
     ignoreWatch: ["./dist"],
     entry: "./src/index.ts",
     dts: true,
+    failOnWarn: true,
     platform: "node",
     outDir: "./dist/node",
     plugins: [unpluginFragno({ platform: "node" })],

package/templates/optional/database/index.ts

@@ -15,7 +15,10 @@ 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>;
+  onNoteCreated?: (
+    idempotencyKey: string,
+    payload: { noteId: string; userId: string },
+  ) => Promise<void>;
 }
 
 const exampleFragmentDefinition = defineFragment<ExampleConfig>("example-fragment")
@@ -23,110 +26,104 @@ const exampleFragmentDefinition = defineFragment<ExampleConfig>("example-fragmen
   .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);
+      // Use this.idempotencyKey for idempotency (e.g., deduplicating webhook calls)
+      await config.onNoteCreated?.(this.idempotencyKey, payload);
     }),
   }))
   .providesBaseService(({ defineService }) => {
     return defineService({
-      createNote: async function (
+      createNote: 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(),
-        };
+        return this.serviceTx(noteSchema)
+          .retrieve((uow) =>
+            uow.findFirst("user", (b) =>
+              b.whereIndex("idx_user_email", (eb) => eb("email", "=", note.userId)),
+            ),
+          )
+          .mutate(({ uow, retrieveResult: [user] }) => {
+            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(),
+            });
+
+            return {
+              id: noteId.valueOf(),
+              content: note.content,
+              userId: user.id.valueOf(),
+              createdAt: new Date(),
+            };
+          })
+          .build();
       },
-      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;
+      getNotes: function () {
+        return this.serviceTx(noteSchema)
+          .retrieve((uow) =>
+            uow.find("note", (b) => b.whereIndex("primary").join((j) => j.author())),
+          )
+          .transformRetrieve(([notes]) => {
+            return notes;
+          })
+          .build();
       },
-      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;
+      getNotesByUser: function (userEmail: string) {
+        return this.serviceTx(noteSchema)
+          .retrieve((uow) =>
+            uow
+              .findFirst("user", (b) =>
+                b.whereIndex("idx_user_email", (eb) => eb("email", "=", userEmail)),
+              )
+              .find("note", (b) => b.whereIndex("primary").join((j) => j.author())),
+          )
+          .transformRetrieve(([user, allNotes]) => {
+            if (!user) {
+              return [];
+            }
+            // Filter notes that belong to this user
+            return allNotes.filter((note) => note.author?.id.toString() === user.id.toString());
+          })
+          .build();
       },
-      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,
-        };
+      updateNote: function (noteId: string, content: string) {
+        return this.serviceTx(noteSchema)
+          .retrieve((uow) =>
+            uow.findFirst("note", (b) =>
+              b.whereIndex("primary", (eb) => eb("id", "=", noteId)).join((j) => j.author()),
+            ),
+          )
+          .mutate(({ uow, retrieveResult: [note] }) => {
+            if (!note) {
+              throw new Error("Note not found");
+            }
+
+            if (!note.author) {
+              throw new Error("Note author not found");
+            }
+
+            // Update with optimistic concurrency control (.check())
+            uow.update("note", note.id, (b) => b.set({ content }).check());
+
+            return {
+              id: note.id.valueOf(),
+              content,
+              userId: note.author.id.valueOf(),
+              createdAt: note.createdAt,
+            };
+          })
+          .build();
       },
     });
   })
@@ -151,18 +148,11 @@ const exampleRoutesFactory = defineRoutes(exampleFragmentDefinition).create(
         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;
-          });
-
-          const notes = await result;
+          const [notes] = await this.handlerTx()
+            .withServiceCalls(() => [
+              userEmail ? services.getNotesByUser(userEmail) : services.getNotes(),
+            ])
+            .execute();
 
           return json(
             notes
@@ -192,28 +182,17 @@ const exampleRoutesFactory = defineRoutes(exampleFragmentDefinition).create(
         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 });
+          const [note] = await this.handlerTx({
+            // Retry policy for optimistic concurrency conflicts
+            retryPolicy: new ExponentialBackoffRetryPolicy({
+              maxRetries: 5,
+              initialDelayMs: 10,
+              maxDelayMs: 250,
+            }),
+          })
+            .withServiceCalls(() => [services.createNote({ content, userId: userEmail })])
+            .execute();
 
-              // 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);
         },
       }),
@@ -233,27 +212,16 @@ const exampleRoutesFactory = defineRoutes(exampleFragmentDefinition).create(
           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 this.handlerTx({
+            retryPolicy: new ExponentialBackoffRetryPolicy({
+              maxRetries: 5,
+              initialDelayMs: 10,
+              maxDelayMs: 250,
+            }),
+          })
+            .withServiceCalls(() => [services.updateNote(noteId, content)])
+            .execute();
 
-          const note = await result;
           return json(note);
         },
       }),

package/templates/optional/database/schema.ts

@@ -1,6 +1,6 @@
 import { column, idColumn, referenceColumn, schema } from "@fragno-dev/db/schema";
 
-export const noteSchema = schema((s) => {
+export const noteSchema = schema("example-fragment", (s) => {
   return s
     .addTable("user", (t) => {
       return t