fix: update scoped service layer pattern to use Effect.Service's scoped property

Update pattern to use Effect.Service's scoped property instead of Layer.scoped
Add proper resource cleanup with Effect.addFinalizer
Improve example with better type definitions and comments
Fix program execution to use Effect.scoped properly
Regenerate published version through pipeline
This fixes the pattern to show the recommended way of creating service layers around managed resources in Effect.

Author: PaulJPhilp

content/published/scoped-service-layer.mdx

@@ -3,10 +3,10 @@ title: "Create a Service Layer from a Managed Resource"
 id: "scoped-service-layer"
 skillLevel: "intermediate"
 useCase: ["Resource Management", "Dependency Injection", "Application Architecture"]
-summary: "Use the `scoped` property of Effect.Service to transform a managed resource into a shareable, application-wide service."
+summary: "Use `Layer.scoped` with `Effect.Service` to transform a managed resource into a shareable, application-wide service."
 tags: ["resource", "layer", "scope", "service", "dependency-injection", "context", "acquire-release"]
 rule:
-  description: "Provide a managed resource to the application context using the `scoped` property of Effect.Service."
+  description: "Provide a managed resource to the application context using `Layer.scoped`."
 related: ["acquire-release-bracket"]
 author: "PaulJPhilp"
 ---
@@ -15,7 +15,7 @@ author: "PaulJPhilp"
 
 ## Guideline
 
-Define a service using `class MyService extends Effect.Service(...)`.   Implement the service using the `scoped` property of the service class. This property should be a scoped `Effect` (typically from `Effect.acquireRelease`) that builds and releases the underlying resource.
+Define a service using `class MyService extends Effect.Service(...)` and provide a `scoped` property in the implementation object. This property should be an `Effect` (typically from `Effect.acquireRelease`) that builds and releases the underlying resource.
 
 ## Rationale
 
@@ -24,36 +24,52 @@ This pattern is the key to building robust, testable, and leak-proof application
 ## Good Example
 
 ```typescript
-import { Effect, Layer, Console } from "effect";
+import { Effect, Console } from "effect";
 
-interface DbOps {
-  query: (sql: string) => Effect.Effect<string[], never, never>;
+// 1. Define the service interface
+interface DatabaseService {
+  readonly query: (sql: string) => Effect.Effect<string[], never, never>
 }
 
-// 1. Define the service using Effect.Service
-class Database extends Effect.Service<DbOps>()(
+// 2. Define the service implementation with scoped resource management
+class Database extends Effect.Service<DatabaseService>()(
   "Database",
   {
+    // The scoped property manages the resource lifecycle
     scoped: Effect.gen(function* () {
       const id = Math.floor(Math.random() * 1000);
+      
+      // Acquire the connection
       yield* Console.log(`[Pool ${id}] Acquired`);
+      
+      // Setup cleanup to run when scope closes
+      yield* Effect.addFinalizer(() => 
+        Console.log(`[Pool ${id}] Released`)
+      );
+      
+      // Return the service implementation
       return {
-        query: (sql: string): Effect.Effect<string[], never, never> =>
-          Effect.sync(() => [`Result for '${sql}' from pool ${id}`])
+        query: (sql: string) => Effect.sync(() => 
+          [`Result for '${sql}' from pool ${id}`]
+        )
       };
     })
   }
 ) {}
 
-// This program depends on the abstract Database service
+// 3. Use the service in your program
 const program = Effect.gen(function* () {
   const db = yield* Database;
   const users = yield* db.query("SELECT * FROM users");
   yield* Console.log(`Query successful: ${users[0]}`);
 });
 
-// Provide the live implementation to run the program
-Effect.runPromise(Effect.provide(program, Database.Default));
+// 4. Run the program with scoped resource management
+Effect.runPromise(
+  Effect.scoped(program).pipe(
+    Effect.provide(Database.Default)
+  )
+);
 
 /*
 Output:

content/raw/scoped-service-layer.mdx

@@ -15,7 +15,7 @@ author: "PaulJPhilp"
 
 ## Guideline
 
-Define a service using `class MyService extends Effect.Service(...)`.   Implement the service using the `scoped` property of the service class. This property should be a scoped `Effect` (typically from `Effect.acquireRelease`) that builds and releases the underlying resource.
+Define a service using `class MyService extends Effect.Service(...)` and provide a `scoped` property in the implementation object. This property should be an `Effect` (typically from `Effect.acquireRelease`) that builds and releases the underlying resource.
 
 ## Rationale
 

content/src/scoped-service-layer.ts

@@ -1,33 +1,49 @@
-import { Effect, Layer, Console } from "effect";
+import { Effect, Console } from "effect";
 
-interface DbOps {
-  query: (sql: string) => Effect.Effect<string[], never, never>;
+// 1. Define the service interface
+interface DatabaseService {
+  readonly query: (sql: string) => Effect.Effect<string[], never, never>
 }
 
-// 1. Define the service using Effect.Service
-class Database extends Effect.Service<DbOps>()(
+// 2. Define the service implementation with scoped resource management
+class Database extends Effect.Service<DatabaseService>()(
   "Database",
   {
+    // The scoped property manages the resource lifecycle
     scoped: Effect.gen(function* () {
       const id = Math.floor(Math.random() * 1000);
+      
+      // Acquire the connection
       yield* Console.log(`[Pool ${id}] Acquired`);
+      
+      // Setup cleanup to run when scope closes
+      yield* Effect.addFinalizer(() => 
+        Console.log(`[Pool ${id}] Released`)
+      );
+      
+      // Return the service implementation
       return {
-        query: (sql: string): Effect.Effect<string[], never, never> =>
-          Effect.sync(() => [`Result for '${sql}' from pool ${id}`])
+        query: (sql: string) => Effect.sync(() => 
+          [`Result for '${sql}' from pool ${id}`]
+        )
       };
     })
   }
 ) {}
 
-// This program depends on the abstract Database service
+// 3. Use the service in your program
 const program = Effect.gen(function* () {
   const db = yield* Database;
   const users = yield* db.query("SELECT * FROM users");
   yield* Console.log(`Query successful: ${users[0]}`);
 });
 
-// Provide the live implementation to run the program
-Effect.runPromise(Effect.provide(program, Database.Default));
+// 4. Run the program with scoped resource management
+Effect.runPromise(
+  Effect.scoped(program).pipe(
+    Effect.provide(Database.Default)
+  )
+);
 
 /*
 Output:

rules/by-use-case/application-architecture.md

@@ -75,36 +75,52 @@ We define two completely independent services, `Database` and `ApiClient`, each
 
 ### Example
 ```typescript
-import { Effect, Layer, Console } from "effect";
+import { Effect, Console } from "effect";
 
-interface DbOps {
-  query: (sql: string) => Effect.Effect<string[], never, never>;
+// 1. Define the service interface
+interface DatabaseService {
+  readonly query: (sql: string) => Effect.Effect<string[], never, never>
 }
 
-// 1. Define the service using Effect.Service
-class Database extends Effect.Service<DbOps>()(
+// 2. Define the service implementation with scoped resource management
+class Database extends Effect.Service<DatabaseService>()(
   "Database",
   {
+    // The scoped property manages the resource lifecycle
     scoped: Effect.gen(function* () {
       const id = Math.floor(Math.random() * 1000);
+      
+      // Acquire the connection
       yield* Console.log(`[Pool ${id}] Acquired`);
+      
+      // Setup cleanup to run when scope closes
+      yield* Effect.addFinalizer(() => 
+        Console.log(`[Pool ${id}] Released`)
+      );
+      
+      // Return the service implementation
       return {
-        query: (sql: string): Effect.Effect<string[], never, never> =>
-          Effect.sync(() => [`Result for '${sql}' from pool ${id}`])
+        query: (sql: string) => Effect.sync(() => 
+          [`Result for '${sql}' from pool ${id}`]
+        )
       };
     })
   }
 ) {}
 
-// This program depends on the abstract Database service
+// 3. Use the service in your program
 const program = Effect.gen(function* () {
   const db = yield* Database;
   const users = yield* db.query("SELECT * FROM users");
   yield* Console.log(`Query successful: ${users[0]}`);
 });
 
-// Provide the live implementation to run the program
-Effect.runPromise(Effect.provide(program, Database.Default));
+// 4. Run the program with scoped resource management
+Effect.runPromise(
+  Effect.scoped(program).pipe(
+    Effect.provide(Database.Default)
+  )
+);
 
 /*
 Output:

rules/by-use-case/dependency-injection.md

@@ -75,36 +75,52 @@ We define two completely independent services, `Database` and `ApiClient`, each
 
 ### Example
 ```typescript
-import { Effect, Layer, Console } from "effect";
+import { Effect, Console } from "effect";
 
-interface DbOps {
-  query: (sql: string) => Effect.Effect<string[], never, never>;
+// 1. Define the service interface
+interface DatabaseService {
+  readonly query: (sql: string) => Effect.Effect<string[], never, never>
 }
 
-// 1. Define the service using Effect.Service
-class Database extends Effect.Service<DbOps>()(
+// 2. Define the service implementation with scoped resource management
+class Database extends Effect.Service<DatabaseService>()(
   "Database",
   {
+    // The scoped property manages the resource lifecycle
     scoped: Effect.gen(function* () {
       const id = Math.floor(Math.random() * 1000);
+      
+      // Acquire the connection
       yield* Console.log(`[Pool ${id}] Acquired`);
+      
+      // Setup cleanup to run when scope closes
+      yield* Effect.addFinalizer(() => 
+        Console.log(`[Pool ${id}] Released`)
+      );
+      
+      // Return the service implementation
       return {
-        query: (sql: string): Effect.Effect<string[], never, never> =>
-          Effect.sync(() => [`Result for '${sql}' from pool ${id}`])
+        query: (sql: string) => Effect.sync(() => 
+          [`Result for '${sql}' from pool ${id}`]
+        )
       };
     })
   }
 ) {}
 
-// This program depends on the abstract Database service
+// 3. Use the service in your program
 const program = Effect.gen(function* () {
   const db = yield* Database;
   const users = yield* db.query("SELECT * FROM users");
   yield* Console.log(`Query successful: ${users[0]}`);
 });
 
-// Provide the live implementation to run the program
-Effect.runPromise(Effect.provide(program, Database.Default));
+// 4. Run the program with scoped resource management
+Effect.runPromise(
+  Effect.scoped(program).pipe(
+    Effect.provide(Database.Default)
+  )
+);
 
 /*
 Output:

rules/by-use-case/resource-management.md

@@ -114,36 +114,52 @@ in the event of errors or interruptions.
 
 ### Example
 ```typescript
-import { Effect, Layer, Console } from "effect";
+import { Effect, Console } from "effect";
 
-interface DbOps {
-  query: (sql: string) => Effect.Effect<string[], never, never>;
+// 1. Define the service interface
+interface DatabaseService {
+  readonly query: (sql: string) => Effect.Effect<string[], never, never>
 }
 
-// 1. Define the service using Effect.Service
-class Database extends Effect.Service<DbOps>()(
+// 2. Define the service implementation with scoped resource management
+class Database extends Effect.Service<DatabaseService>()(
   "Database",
   {
+    // The scoped property manages the resource lifecycle
     scoped: Effect.gen(function* () {
       const id = Math.floor(Math.random() * 1000);
+      
+      // Acquire the connection
       yield* Console.log(`[Pool ${id}] Acquired`);
+      
+      // Setup cleanup to run when scope closes
+      yield* Effect.addFinalizer(() => 
+        Console.log(`[Pool ${id}] Released`)
+      );
+      
+      // Return the service implementation
       return {
-        query: (sql: string): Effect.Effect<string[], never, never> =>
-          Effect.sync(() => [`Result for '${sql}' from pool ${id}`])
+        query: (sql: string) => Effect.sync(() => 
+          [`Result for '${sql}' from pool ${id}`]
+        )
       };
     })
   }
 ) {}
 
-// This program depends on the abstract Database service
+// 3. Use the service in your program
 const program = Effect.gen(function* () {
   const db = yield* Database;
   const users = yield* db.query("SELECT * FROM users");
   yield* Console.log(`Query successful: ${users[0]}`);
 });
 
-// Provide the live implementation to run the program
-Effect.runPromise(Effect.provide(program, Database.Default));
+// 4. Run the program with scoped resource management
+Effect.runPromise(
+  Effect.scoped(program).pipe(
+    Effect.provide(Database.Default)
+  )
+);
 
 /*
 Output: