prisma-sharding 0.0.6 → 0.0.7

package/README.md

@@ -2,6 +2,13 @@
 
 Lightweight database sharding library for Prisma with connection pooling, health monitoring, and CLI tools.
 
+## Backward Compatibility Policy
+
+This package treats its existing public API as stable. Production-hardening releases do not rename
+commands or public methods, change return shapes, move the package import path, remove exported
+errors, or add required fields to public outputs. Internal routing, execution, health, and CLI
+safety fixes preserve existing application code and the compact default CLI format.
+
 ## Installation
 
 ```bash
@@ -38,76 +45,77 @@ await sharding.connect();
 
 ## API
 
-| Method                       | Description                                   |
-| ---------------------------- | --------------------------------------------- |
-| `getShard(key)`              | Get Prisma client for a given key             |
-| `getShardById(shardId)`      | Get Prisma client by shard ID                 |
-| `getRandomShard()`           | Get random shard (for new records)            |
-| `findFirst(fn)`              | Search across all shards, return first result |
-| `runOnAll(fn)`               | Execute on all shards                         |
-| `getHealth()`                | Get health status of all shards               |
-| `connect()` / `disconnect()` | Lifecycle methods                             |
-
-### Step 2: Create a User (Assign to a Shard)
-
-New records should be created on a random shard for even distribution.
-
-```ts
-import { sharding } from '@/config/prisma';
+| Method                       | Description                                    |
+| ---------------------------- | ---------------------------------------------- |
+| `getShard(key)`              | Deterministic client for a routing key         |
+| `getShardById(shardId)`      | Client for a persisted shard owner             |
+| `getRandomShard()`           | Random assignment; ownership must be recorded  |
+| `findFirst(fn)`              | Bounded exception-path search across shards    |
+| `runOnAll(fn)`               | Bounded admin/analytics execution              |
+| `getHealth()`                | Health status using the existing output shape  |
+| `connect()` / `disconnect()` | Lifecycle methods                              |
 
-const client = sharding.getRandomShard();
+## Shard Ownership
 
-const user = await client.user.create({
-  data: {
-    email: 'user@example.com',
-    username: 'new_user',
-  },
-});
-```
+Every record needs one authoritative shard owner. Choose one of these patterns and use it
+consistently. Cross-shard search is a recovery path, not an ownership strategy.
 
-## Step 3: Access User by ID (Shard Routing)
+### Pattern A: Deterministic Ownership
 
-When you have a user ID, Prisma Sharding routes you to the correct shard automatically.
+Generate or obtain the routing key before inserting the record, then use the same key for every
+future operation:
 
-```ts
-const userId = 'abc123';
+```typescript
+import { sharding } from '@/config/prisma';
 
+const userId = crypto.randomUUID();
 const client = sharding.getShard(userId);
+const user = await client.user.create({
+  data: { id: userId, email: 'user@example.com', username: 'new_user' },
+});
 
-const user = await client.user.findUnique({
+const sameUser = await sharding.getShard(userId).user.findUnique({
   where: { id: userId },
 });
 ```
 
-`Important rule:`
-
-Once you get the shard client using a user ID, **all future operations for that user must use this same client**.
+Modulo routing uses the existing `hashString(key) % shardCount` placement. The hash function and
+configured shard order are data-placement contracts: changing either can move existing records and
+requires an explicit migration or dual-read plan. Consistent hashing also preserves configured
+shard IDs and supports custom IDs such as `tenant-east`.
 
-That includes:
+### Pattern B: Assigned Ownership
 
-- Reading user data
-- Updating user data
-- Creating related records (profiles, posts, settings, etc)
+Random assignment can distribute new records, but the application must persist the assigned shard
+ID in a directory table, tenant registry, or equivalent ownership metadata:
 
-Every user belongs to exactly one shard. Their entire data lives on that shard only.
-
-Do **not** switch shards or use a random shard for user related actions.
+```typescript
+const { client, shardId } = sharding.getRandomShardWithInfo();
+const user = await client.user.create({ data: { email, username } });
 
-Always do this:
+await shardDirectory.create({ data: { recordId: user.id, shardId } });
 
-```ts
-const client = sharding.getShard(userId);
+const ownership = await shardDirectory.findUniqueOrThrow({
+  where: { recordId: user.id },
+});
+const sameUser = await sharding
+  .getShardById(ownership.shardId)
+  .user.findUnique({ where: { id: user.id } });
 ```
 
-This guarantees all user data stays on the correct shard and avoids cross shard bugs.
+The existing `getRandomShard()` method still returns only a client. Calling it for a write and
+later calling `getShard(record.id)` is **not guaranteed to select the same shard**. If you use
+`getRandomShard()`, your application needs another reliable way to record which shard was selected.
+`weight` affects random assignment only; it never changes deterministic `getShard(key)` placement.
 
-### Step 4: Find User Without ID (Cross Shard Search)
+### Find Without Ownership Metadata
 
-If you do not have the user ID, search all shards in parallel.
-Use this only when necessary.
+`findFirst()` is bounded, timed, health-aware, and returns when the first non-null result arrives.
+Even so, one call can create work on multiple databases. Treat it as an exception, recovery, or
+administrative path. At high traffic it should not be the normal login, email lookup, user lookup,
+or tenant lookup path; maintain shard ownership metadata instead.
 
 ```typescript
-// Find user by email across ALL shards (parallel execution)
 const { result: user, client } = await sharding.findFirst(async (c) =>
   c.user.findFirst({ where: { email } })
 );
@@ -121,10 +129,10 @@ if (user && client) {
 }
 ```
 
-## Step 5: Run on All Shards (Admin or Analytics)
+### Run on All Shards
 
 ```typescript
-// Get counts from all shards
+// Appropriate for bounded admin or analytics work, not a normal request path.
 const counts = await sharding.runOnAll(async (client) => client.user.count());
 const totalUsers = counts.reduce((sum, count) => sum + count, 0);
 
@@ -136,6 +144,13 @@ const results = await sharding.runOnAllWithDetails(async (client, shardId) => {
 
 ### Health Monitoring
 
+`connect()` initializes all clients and starts background warmup for clients that implement
+`$connect()`, followed by an initial `SELECT 1` when `$queryRaw` is available. Warmup does not delay
+client availability, preserving existing startup behavior. Periodic checks have a deadline, cannot
+overlap, and update the existing `ShardHealth` shape. Deterministic routing still returns the
+record's owner when it is marked unhealthy; cross-shard work schedules healthy, lower-latency
+shards first.
+
 ```typescript
 // Get health of all shards
 const health = sharding.getHealth();
@@ -169,6 +184,7 @@ Add to your `package.json`:
 {
   "scripts": {
     "db:update": "prisma-sharding-update",
+    "migrate:shards": "prisma-sharding-migrate",
     "db:studio": "prisma-sharding-studio",
     "test:shards": "prisma-sharding-test"
   }
@@ -196,11 +212,12 @@ PRISMA_SHARDING_VERBOSE=false # optional, library lifecycle logs
 
 #### `prisma-sharding-update` (Recommended)
 
-The "All-in-One" command. It generates Prisma Client types and migrates all shards.
-**Use this whenever you change `schema.prisma`.**
+The "All-in-One" development command generates Prisma Client types and synchronizes local/dev
+shards. Use this whenever you change `schema.prisma` during development. It is not a production
+migration workflow.
 
 1. Runs `prisma generate` (Updates TypeScript types)
-2. Runs `prisma db push` on all shards (Updates Databases)
+2. Runs `prisma db push` on all shards (Synchronizes development databases)
 
 ```bash
 yarn db:update
@@ -224,26 +241,34 @@ sync are running. The loader is replaced by the completed row and is disabled fo
 Set `SHARD_CLI_VERBOSE=true` or `SHARD_UPDATE_VERBOSE=true` to include Prisma command
 output, masked database URLs, and detailed diagnostics.
 
-**With Flags:**
-You can pass flags like `--force-reset` if you need to wipe data due to schema conflicts.
+Existing flags remain unchanged and are forwarded as provided. For example:
 
 ```bash
 yarn db:update --force-reset
 
 ```
 
+The command does not inject `--accept-data-loss` automatically.
+
 #### `prisma-sharding-migrate`
 
-Only pushes schema to all shards (skips type generation). Useful for production deployment pipelines.
+This is the production/staging path. For each shard it checks migration status and runs
+`prisma migrate deploy`, applying committed migration artifacts without generating the client,
+resetting the database, or using `db push`.
 
 ```bash
 yarn migrate:shards
 
 ```
 
+Any failed shard makes the command exit non-zero and remains visible in the compact results.
 This command uses the same compact shard rows as `db:update`. Set
 `SHARD_CLI_VERBOSE=true` or `SHARD_MIGRATE_VERBOSE=true` for Prisma command output.
 
+Do not use `prisma db push` as a production migration strategy. Commit and review the Prisma
+migration directory, then run `prisma-sharding-migrate` during deployment. Verbose mode includes
+sanitized status/deploy commands, masked database URLs, exit codes, shard IDs, and next-step hints.
+
 #### `prisma-sharding-studio`
 
 Start Prisma Studio for all shards on sequential ports.
@@ -387,7 +412,7 @@ Verified 5/5 users on correct shards
 | `shards`                  | `ShardConfig[]`                 | Required   | Array of shard configurations     |
 | `strategy`                | `'modulo' \| 'consistent-hash'` | `'modulo'` | Routing algorithm                 |
 | `createClient`            | `(url, shardId) => TClient`     | Required   | Factory to create Prisma clients  |
-| `healthCheckIntervalMs`   | `number`                        | `30000`    | Health check frequency            |
+| `healthCheckIntervalMs`   | `number`                        | `30000`    | Positive health check frequency   |
 | `circuitBreakerThreshold` | `number`                        | `3`        | Failures before marking unhealthy |
 
 ### Shard Config
@@ -396,7 +421,7 @@ Verified 5/5 users on correct shards
 interface ShardConfig {
   id: string; // Unique identifier (e.g., 'shard_1')
   url: string; // PostgreSQL connection string
-  weight?: number; // Optional weight for distribution
+  weight?: number; // Positive random-assignment weight only
   isReadReplica?: boolean;
 }
 ```
@@ -413,12 +438,64 @@ strategy: 'modulo';
 
 ### Consistent Hash
 
-Minimizes data movement when adding/removing shards.
+Uses a precomputed virtual-node ring and binary search. Custom and non-sequential shard IDs are
+supported. Adding or removing shards still changes ownership for part of the keyspace, so plan data
+movement before changing a production shard list.
 
 ```typescript
 strategy: 'consistent-hash';
 ```
 
+## Architecture and Scaling
+
+The public `PrismaSharding` layer validates and delegates without changing its established surface.
+Internally, the router owns key placement, the manager owns clients and health state, and one
+cross-shard executor owns concurrency, deadlines, health-aware scheduling, stable result ordering,
+and failure isolation. CLI commands share one shard parser and one sanitized child-process runner.
+
+| Layer | Responsibility |
+| --- | --- |
+| Public API | Validate, delegate, and preserve existing result shapes |
+| Router | Stable deterministic placement and weighted random assignment |
+| Shard manager | Client lifecycle, initial verification, health, and shutdown |
+| Cross-shard executor | Shared concurrency, deadlines, ordering, and failure isolation |
+| CLI | Safe migration/update/test/Studio orchestration with compact output |
+
+Low-level execution behavior is intentionally internal: fan-out concurrency and deadlines are
+central defaults, the hash function is unchanged, health checks use typed Prisma-like capability
+guards, successful `runOnAll()` results retain configured shard order, and errors stay isolated in
+the existing detailed result shape.
+
+Normal request flow should be:
+
+```text
+routing key or directory lookup -> one shard -> one Prisma operation
+```
+
+`findFirst()` and `runOnAll()` use bounded concurrency and per-shard deadlines, but they still
+multiply database work and tail-latency exposure. Reserve them for recovery, administration, and
+analytics. Pending Prisma queries may not be cancellable after an early `findFirst()` result, so
+the caller can resolve before all already-started database work has physically stopped.
+
+The executor deadline limits how long the package waits; it does **not** cancel the underlying
+Prisma or PostgreSQL query. Configure a database-level deadline as well, such as PostgreSQL
+`statement_timeout` or the equivalent adapter/provider query timeout, so timed-out work cannot
+continue consuming database resources indefinitely.
+
+### Connection Pool Budgeting
+
+Each shard client owns or uses a connection pool. Budget the fleet-wide maximum as:
+
+```text
+application instances × shards per instance × connections per shard pool
+```
+
+For example, 20 application instances × 8 shards × 10 connections can attempt 1,600 database
+connections. Set the adapter's pool limit and connection timeout deliberately per application
+instance and per shard. At larger fleet sizes, use PgBouncer or provider-managed pooling and verify
+that the database's total connection budget includes migrations, administration, and failover
+headroom. The sharding package does not create hidden extra Prisma clients.
+
 ## Error Handling
 
 ```typescript

package/dist/cli/migrate.js

@@ -89,36 +89,152 @@ var createCliLoader = (label, message, enabled = true) => {
 // src/cli/utils/command.ts
 var import_child_process = require("child_process");
 var import_path = __toESM(require("path"));
+
+// src/constants/internal.ts
+var INTERNAL_DEFAULTS = {
+  HEALTH_CHECK_TIMEOUT_MS: 5e3,
+  CROSS_SHARD_CONCURRENCY: 4,
+  CROSS_SHARD_TIMEOUT_MS: 1e4,
+  CLI_COMMAND_TIMEOUT_MS: 12e4,
+  CLI_FORCE_KILL_GRACE_MS: 5e3,
+  CLI_MAX_OUTPUT_LENGTH: 1e6,
+  CLI_TEST_TCP_TIMEOUT_MS: 5e3,
+  CLI_TEST_COMMAND_TIMEOUT_MS: 15e3,
+  STUDIO_BASE_PORT: 51212,
+  STUDIO_REUSE_EXISTING: true,
+  STUDIO_STRICT_PORT_CHECK: false,
+  STUDIO_START_TIMEOUT_MS: 15e3,
+  STUDIO_STABILITY_MS: 500,
+  STUDIO_SHUTDOWN_TIMEOUT_MS: 5e3
+};
+
+// src/utils/sanitize.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var maskDatabaseUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url.replace(/:[^:@]+@/, ":***@");
+  }
+};
+var sanitizeDatabaseText = (output, databaseUrls) => {
+  let sanitized = output;
+  for (const url of databaseUrls) {
+    sanitized = sanitized.replace(new RegExp(escapeRegExp(url), "g"), maskDatabaseUrl(url));
+    try {
+      const password = new URL(url).password;
+      if (password.length >= 4) {
+        sanitized = sanitized.replace(
+          new RegExp(escapeRegExp(decodeURIComponent(password)), "g"),
+          "***"
+        );
+      }
+    } catch {
+    }
+  }
+  return sanitized.replace(
+    /(postgres(?:ql)?:\/\/[^:/\s]+:)[^@\s]+(@)/gi,
+    "$1***$2"
+  );
+};
+
+// src/cli/utils/process.ts
+var isChildProcessRunning = (childProcess) => {
+  return childProcess.exitCode === null && childProcess.signalCode === null;
+};
+var terminateChildProcess = (childProcess, options = {}) => {
+  if (!isChildProcessRunning(childProcess)) {
+    return false;
+  }
+  const signal = options.signal || "SIGTERM";
+  try {
+    if (options.processGroup && childProcess.pid && process.platform !== "win32") {
+      try {
+        process.kill(-childProcess.pid, signal);
+        return true;
+      } catch {
+      }
+    }
+    return childProcess.kill(signal);
+  } catch {
+    return false;
+  }
+};
+
+// src/cli/utils/command.ts
 var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+var OUTPUT_TRUNCATED_MARKER = "\n[output truncated]\n";
+var appendBoundedOutput = (current, chunk, limit) => {
+  const combined = current + chunk;
+  if (combined.length <= limit) {
+    return combined;
+  }
+  if (limit <= OUTPUT_TRUNCATED_MARKER.length) {
+    return combined.slice(-limit);
+  }
+  return OUTPUT_TRUNCATED_MARKER + combined.slice(-(limit - OUTPUT_TRUNCATED_MARKER.length));
+};
+var sanitizeCommandOutput = (output, env = process.env) => {
+  const databaseUrls = Object.entries(env).filter(
+    ([name, value]) => Boolean(value) && (name === "DATABASE_URL" || /^SHARD_\d+_URL$/.test(name))
+  ).map(([, value]) => value);
+  return sanitizeDatabaseText(output, databaseUrls).replace(/(\bpassword\s*[=:]\s*)[^\s,;]+/gi, "$1***");
+};
 var runCommand = (command, args, options = {}) => {
   return new Promise((resolve) => {
     let stdout = "";
     let stderr = "";
     let settled = false;
+    let timedOut = false;
+    let forceKillTimeout;
+    const env = options.env || process.env;
+    const timeoutMs = options.timeoutMs ?? INTERNAL_DEFAULTS.CLI_COMMAND_TIMEOUT_MS;
+    const forceKillGraceMs = options.forceKillGraceMs ?? INTERNAL_DEFAULTS.CLI_FORCE_KILL_GRACE_MS;
+    const maxOutputLength = options.maxOutputLength ?? INTERNAL_DEFAULTS.CLI_MAX_OUTPUT_LENGTH;
+    const processGroup = process.platform !== "win32";
     const child = (0, import_child_process.spawn)(command, args, {
-      env: options.env || process.env,
+      env,
       cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      detached: processGroup,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
     const settle = (result) => {
       if (!settled) {
         settled = true;
-        resolve(result);
+        clearTimeout(timeout);
+        if (forceKillTimeout) {
+          clearTimeout(forceKillTimeout);
+        }
+        const sanitizedResult = {
+          ...result,
+          stdout: sanitizeCommandOutput(result.stdout, env),
+          stderr: sanitizeCommandOutput(result.stderr, env),
+          error: result.error ? sanitizeCommandOutput(result.error, env) : void 0
+        };
+        if (options.verbose) {
+          if (sanitizedResult.stdout) {
+            process.stdout.write(sanitizedResult.stdout);
+          }
+          if (sanitizedResult.stderr) {
+            process.stderr.write(sanitizedResult.stderr);
+          }
+        }
+        resolve(sanitizedResult);
       }
     };
     child.stdout?.on("data", (data) => {
-      const output = data.toString();
-      stdout += output;
-      if (options.verbose) {
-        process.stdout.write(output);
+      if (!settled) {
+        stdout = appendBoundedOutput(stdout, data.toString(), maxOutputLength);
       }
     });
     child.stderr?.on("data", (data) => {
-      const output = data.toString();
-      stderr += output;
-      if (options.verbose) {
-        process.stderr.write(output);
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
       }
     });
     child.once("error", (error) => {
@@ -126,18 +242,35 @@ var runCommand = (command, args, options = {}) => {
         success: false,
         stdout,
         stderr,
-        error: error.message
+        exitCode: null,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : error.message
       });
     });
     child.once("close", (exitCode) => {
       settle({
-        success: exitCode === 0,
+        success: !timedOut && exitCode === 0,
         stdout,
         stderr,
         exitCode,
-        error: exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
       });
     });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminateChildProcess(child, { signal: "SIGTERM", processGroup });
+      forceKillTimeout = setTimeout(() => {
+        terminateChildProcess(child, { signal: "SIGKILL", processGroup });
+        settle({
+          success: false,
+          stdout,
+          stderr,
+          exitCode: null,
+          error: `Command timed out after ${timeoutMs}ms`
+        });
+      }, forceKillGraceMs);
+      forceKillTimeout.unref?.();
+    }, timeoutMs);
+    timeout.unref?.();
   });
 };
 var runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
@@ -161,44 +294,58 @@ var getShardConfigResult = (env = process.env) => {
   }
   return { shards, missingShardIds };
 };
-var getShardConfigs = (env = process.env) => {
-  return getShardConfigResult(env).shards;
-};
-var maskShardUrl = (url) => {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = "***";
-    }
-    return parsed.toString();
-  } catch {
-    return url.replace(/:[^:@]+@/, ":***@");
-  }
-};
+var maskShardUrl = maskDatabaseUrl;
 
 // src/cli/utils/prisma.ts
-var syncShardSchemas = async (shards, extraArgs, verbose) => {
+var executeShardCommand = async (shard, commandArgs, verbose, action) => {
+  const commandEnv = { ...process.env, DATABASE_URL: shard.url };
+  if (verbose) {
+    console.log(`
+${action} ${shard.id}...`);
+    console.log(`Database: ${maskShardUrl(shard.url)}
+`);
+    console.log(
+      `Command: ${sanitizeCommandOutput(`prisma ${commandArgs.join(" ")}`, commandEnv)}`
+    );
+  }
+  const result = await runPrismaCommand(commandArgs, {
+    env: commandEnv,
+    verbose
+  });
+  if (verbose) {
+    console.log(`Exit code: ${result.exitCode ?? "unavailable"}`);
+  }
+  if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
+    console.error(result.error);
+  }
+  if (verbose && !result.success) {
+    console.error(`Next: verify ${shard.id} connectivity and migration state, then retry.`);
+  }
+  return result;
+};
+var deployShardMigrations = async (shards, extraArgs, verbose) => {
   const results = [];
   for (const shard of shards) {
-    const loader = createCliLoader(shard.id, "Syncing", !verbose);
-    if (verbose) {
-      console.log(`
-Syncing ${shard.id}...`);
-      console.log(`Database: ${maskShardUrl(shard.url)}
-`);
-    }
-    const result = await runPrismaCommand(
-      ["db", "push", "--accept-data-loss", ...extraArgs],
-      {
-        env: { ...process.env, DATABASE_URL: shard.url },
-        verbose
-      }
+    const loader = createCliLoader(shard.id, "Migrating", !verbose);
+    const status = await executeShardCommand(
+      shard,
+      ["migrate", "status"],
+      verbose,
+      "Checking migration status for"
     );
-    if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
-      console.error(result.error);
+    if (!status.success) {
+      results.push({ shardId: shard.id, success: false });
+      loader.fail("Failed");
+      continue;
     }
-    results.push({ shardId: shard.id, success: result.success });
-    if (result.success) {
+    const deploy = await executeShardCommand(
+      shard,
+      ["migrate", "deploy", ...extraArgs],
+      verbose,
+      "Migrating"
+    );
+    results.push({ shardId: shard.id, success: deploy.success });
+    if (deploy.success) {
       loader.succeed("Synced");
     } else {
       loader.fail("Failed");
@@ -210,14 +357,18 @@ Syncing ${shard.id}...`);
 // src/cli/migrate.ts
 var migrateAllShards = async () => {
   const verbose = isVerboseEnv(["SHARD_MIGRATE_VERBOSE", "SHARD_CLI_VERBOSE"]);
-  const shards = getShardConfigs();
+  const { shards, missingShardIds } = getShardConfigResult();
   const extraArgs = process.argv.slice(2);
   printCliHeader("\u{1F504}", "Prisma Sharding Migrate");
+  if (missingShardIds.length > 0) {
+    printCliRow("\u274C", "config", `Missing shard URLs: ${missingShardIds.join(", ")}`);
+    process.exit(1);
+  }
   if (shards.length === 0) {
     printCliRow("\u274C", "config", NO_SHARDS_CONFIGURED_MESSAGE);
     process.exit(1);
   }
-  const results = await syncShardSchemas(shards, extraArgs, verbose);
+  const results = await deployShardMigrations(shards, extraArgs, verbose);
   const successful = results.filter((result) => result.success).length;
   const failed = results.length - successful;
   if (failed > 0) {