@shivaedev/platform 0.25.0 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## 0.28.0 - 2026-10-25
+
+### Added
+
+- effect-sql records the database release after successful migrations and coordinates worker drain with typed PostgreSQL heartbeat rows.
+- effect-pg-boss pauses fetching while the database belongs to another release, finishes active jobs, and resumes when its release owns the database again.
+- Platform migration options accept an optional `release` for deployment migration and worker readiness.
+- Generated workers step aside for a newer release and drain on SIGTERM, with queue expiry, stop timeout and Railway draining configured together.
+
+## 0.27.0 - 2026-10-25
+
+### Added
+
+- Look up other users' public names and images with `userProfiles(auth, userIds)` through Better Auth's adapter, without exposing email, role, session or account data.
+- `@shivaedev/platform`: `authDatabase` accepts optional `max` and `application_name` pool settings.
+
+### Changed
+
+- `@shivaedev/create-app`: Starter stories run the web host and worker with test-sized SQL, authentication and jobs pools.
+
+## 0.26.0 - 2026-10-25
+
+### Added
+
+- `@shivaedev/effect-sql` exports `pendingPostgresMigrations` to read pending ledger migration IDs and names and schema component names and details.
+- `@shivaedev/platform` logs migration wait start, periodic progress, completion and timeout through Effect's logger with pending migration and component annotations. `migrations.progressInterval` controls progress logging independently of polling and defaults to 30 seconds.
+- Outbound HTTP client status errors, clock-based Retry-After parsing, lazy same-origin Link pagination, and bounded bytes, text and Schema-decoded JSON response readers.
+- Let `signedInUser` create provider accounts without credentials and expose `storedProviderAccounts` to read account IDs and credential-presence booleans without returning secret values.
+
+### Changed
+
+- `@shivaedev/create-app`'s starter worker uses the host's migration wait logs and keeps its job readiness line.
+
+## 0.25.4 - 2026-10-25
+
+### Changed
+
+- Release with updated workspace dependencies.
+
+## 0.25.3 - 2026-10-25
+
+### Changed
+
+- Release with updated workspace dependencies.
+
+## 0.25.2 - 2026-10-25
+
+### Changed
+
+- Release with updated workspace dependencies.
+
+## 0.25.1 - 2026-10-25
+
+### Changed
+
+- Release with updated workspace dependencies.
+
 ## 0.25.0 - 2026-10-25
 
 ### Added

package/README.md

@@ -96,7 +96,7 @@ Omit `migrations` to host an app without a database. This form creates no SQL po
 
 `appHost` serves unauthenticated `GET /health`. It queries its SQL client on each request and returns `200` only when the query succeeds within two seconds; a missing SQL client, query failure or timeout returns `503`. Both responses have an empty body and `Cache-Control: no-store`. This route also works when the SQL client comes from the application’s `services` Layer. Use it for database readiness checks.
 
-Set `migrations.mode: "check"` on `appDatabase` or a database-backed `appHost` when a separate pre-deploy command owns migrations. Startup reads the ledger and fails with native `MigrationError` (`kind: "BadState"`) if any required migration ID or name is missing or a schema component is pending; it does not run migrations or create a ledger. Later ledger entries are allowed for rolling deployments. Use `migrations.mode: "wait"` for services that can start before that pre-deploy command finishes. It re-reads the ledger and every registered component every second until all are current, then starts the application. Set `migrations.pollInterval` and `migrations.waitTimeout` with Effect duration inputs to change the interval and five-minute timeout. Timeout fails with the same `MigrationError` as `"check"`; interruption stops polling and closes the pool. SQL failures fail immediately. With `mode` omitted or `"migrate"`, startup applies pending ledger migrations with a five-second lock timeout unless `migrations.lockTimeout` overrides it, then applies schema components outside the ledger transaction.
+Set `migrations.mode: "check"` on `appDatabase` or a database-backed `appHost` when a separate pre-deploy command owns migrations. Startup reads the ledger and fails with native `MigrationError` (`kind: "BadState"`) if any required migration ID or name is missing or a schema component is pending; it does not run migrations or create a ledger. Later ledger entries are allowed for rolling deployments. Use `migrations.mode: "wait"` for services that can start before that pre-deploy command finishes. It re-reads the ledger and every registered component every second until all are current, then starts the application. Set `migrations.pollInterval` and `migrations.waitTimeout` with Effect duration inputs to change the interval and five-minute timeout. If the first check finds pending work, Effect’s logger emits `Waiting for database migrations` at info, then `Still waiting for database migrations` every 30 seconds independently of polling. Set `migrations.progressInterval` with an Effect duration input to change that progress interval. These lines carry `pendingMigrations` (ID and name) and `pendingComponents` (name and detail) annotations. A later successful check logs `Database migrations current` once; timeout logs `Timed out waiting for database migrations` with the pending annotations before failing. An initially current schema emits none of these lines. The host adds no connection details or secrets to these diagnostics. Timeout fails with the same `MigrationError` as `"check"`; interruption stops polling and closes the pool. SQL failures fail immediately. With `mode` omitted or `"migrate"`, startup applies pending ledger migrations with a five-second lock timeout unless `migrations.lockTimeout` overrides it, then applies schema components outside the ledger transaction.
 
 Pass `migrations.components` beside `loader` for storage managed by another engine. For pg-boss, register `pgBossSchema({ schema: "app_jobs" })` from `@shivaedev/effect-pg-boss/server/schema.ts`, then start every jobs Layer with `migrate: false`. `check` and `wait` use the same `MigrationError` readout for pending ledger IDs and component names and details, including pg-boss’s installed and required versions.
 
@@ -263,6 +263,18 @@ export const sessions = {
 
 The application's `auth` owns its storage and session configuration. A null lookup becomes a missing session. A thrown or rejected lookup is logged in redacted form and fails with the generic `AuthUnavailable` message. It remains a failure even on an RPC with optional authentication.
 
+### Reading other users' public profiles
+
+Use `userProfiles(auth, userIds)` in server code to display the names of users who made changes. Pass the `auth` instance returned by `betterAuthMount` and a list of user IDs.
+
+```ts
+import { userProfiles } from "@shivaedev/platform/server/better-auth/userProfiles.ts";
+
+const profiles = yield* userProfiles(auth, changedByUserIds);
+```
+
+The Effect returns an array of `{ id, name, image }`, with `image: null` when unset and unknown IDs omitted. It reads duplicate IDs once in one storage query through Better Auth's adapter, honoring the application's model and field mappings. An empty list returns an empty array without querying storage. Each lookup reads the current profile, including names changed through Better Auth. The result never includes email, role, session or account data. A storage failure logs its cause in redacted form and fails with a generic `AuthUnavailable`, without exposing provider exception details to the caller.
+
 ### Reading the signed-in user
 
 When a handler needs the current user's name and email, declare `AuthenticatedUser` and read `SessionUser`. `Identity` keeps its `{ id }` shape; the new middleware supplies both services for that invocation. Its provider must return `user: { id, name, email }`, described by `UserSessionShape`.
@@ -520,6 +532,33 @@ For native RPC serialization, `schemaSensitiveKeys(group, extraKeys?)` returns a
 
 For a native RPC server composed without `appHost`, `requestTracingLayer({ sensitive })` accepts a key predicate; `isSensitiveKey` supplies the default credential rules. `redactingErrorReporter(reporter, sensitive?)` wraps an Effect error reporter and passes it redacted failure and defect causes while preserving reporting hints such as severity and redacted attributes.
 
+### Calling outside APIs
+
+Use Effect's HTTP client with `filterStatus`, `paginate` and the bounded body readers:
+
+```ts
+import { Effect, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { readBoundedJson } from "@shivaedev/platform/http-client/body.ts";
+import { filterStatus } from "@shivaedev/platform/http-client/filterStatus.ts";
+import { paginate } from "@shivaedev/platform/http-client/paginate.ts";
+
+const items = Effect.gen(function* () {
+  const client = filterStatus(yield* HttpClient.HttpClient);
+  return yield* paginate(client, HttpClientRequest.get("https://api.example/items")).pipe(
+    Stream.mapEffect((response) => readBoundedJson(response, 64 * 1024, Schema.Array(Schema.String))),
+    Stream.runCollect,
+    Effect.map((pages) => pages.flat()),
+  );
+});
+```
+
+Provide a native client Layer such as `FetchHttpClient.layer` from `effect/http`. `filterStatus` passes 2xx responses through and fails other statuses with Schema tagged errors from `http-client/errors.ts`: `RemoteUnauthorized` (401), `RemoteNotFound` (404), `RemoteGone` (410), `RemoteRateLimited` (429, or 503 carrying `Retry-After`) and `RemoteHttpError` for other statuses. Errors carry the method, URL without its query string and status, without headers or body. `RemoteRateLimited.retryAfter` is an optional UTC `DateTime`: delay-seconds use Effect's clock, and HTTP dates name the instant directly. Missing or invalid values leave it undefined.
+
+`paginate` follows quoted or unquoted `rel=next`, including headers with multiple links and relations, resolves relative links and stops at the last page. Taking one page sends one request. A next link on another origin fails with `PaginationLinkError` before that request is sent.
+
+`readBoundedBody(response, limit)` returns bytes; `readBoundedText` decodes UTF-8, and `readBoundedJson(response, limit, schema)` decodes JSON through the supplied Schema. Limits are bytes. An oversized `Content-Length` fails with `ResponseBodyTooLarge` before reading the body; a chunked body that exceeds the limit fails during the read. The error carries `limit`.
+
 ### Promise callers: one application runtime
 
 Build the application Layer once. `runWithServices` supplies an invocation's overrides to subsequent calls on the same runtime, across Promise awaits:
@@ -593,6 +632,8 @@ const authentication = Effect.gen(function* () {
 });
 ```
 
+`authDatabase(url, { max, application_name })` accepts an optional maximum connection count and PostgreSQL application name, passed to `pg.Pool`. Omit the settings to use pg’s defaults.
+
 Run this Effect in the host's scope. The pool logs idle-client errors at Debug and replaces failed connections on the next query; closing the scope disconnects its clients. A rejected auth handler returns HTTP 503 with `Authentication is temporarily unavailable`.
 
 The mount reads `BETTER_AUTH_SECRET` unless options supply `secret`. `PUBLIC_URL` supplies the default base URL, trusted origin and HTTPS secure-cookie setting; without it, the defaults accept loopback HTTP. Application options can override those defaults. RPC Origin policy remains an application choice.
@@ -654,11 +695,43 @@ const testAuth = betterAuth({
 const { user, headers, cookies } = await signedInUser(testAuth, {
   email: "member@example.test",
   name: "Member",
+  providerAccounts: [{ providerId: "github", accountId: "123" }],
   role: "user,admin",
 });
 ```
 
-`options` is the application's auth configuration. `signedInUser` saves the supplied user fields and mints one session through Better Auth's `testUtils`, without OAuth or password hashing. It returns Better Auth's login result: the user, session, signed request headers, browser cookies and token. Roles require the application's role plugin, such as Better Auth's `admin()`. Send `headers` to the real host, or pass `cookies` to test-story's `seedCookies` in a DOM story after setting its host location with `domFetch`. Keep a real sign-in story for each sign-in flow; feature stories start from the minted precondition.
+`options` is the application's auth configuration. `signedInUser` saves the supplied user fields, creates each optional `providerAccounts` entry for that user through Better Auth's internal adapter, and mints one session through Better Auth's `testUtils`, without OAuth or password hashing. The accounts carry no tokens or password. Omitting `providerAccounts` creates only the user and session. It returns Better Auth's login result: the user, session, signed request headers, browser cookies and token. Roles require the application's role plugin, such as Better Auth's `admin()`. Send `headers` to the real host, or pass `cookies` to test-story's `seedCookies` in a DOM story after setting its host location with `domFetch`. Keep a real sign-in story for each sign-in flow; feature stories start from the minted precondition.
+
+Use `storedProviderAccounts(auth, userId)` to observe credential storage through Better Auth's internal adapter. It returns account and provider IDs with `hasAccessToken`, `hasRefreshToken`, `hasIdToken` and `hasPassword` booleans. It never returns token values, passwords or password hashes. A DOM story kit that exposes its test auth instance and a session readout can use both helpers:
+
+```ts
+import { Effect } from "effect";
+import { expect } from "vitest";
+import { seedCookies } from "@shivaedev/test-story/server/seedCookies.ts";
+import { signedInUser, storedProviderAccounts } from "@shivaedev/platform/server/better-auth/testing.ts";
+
+const member = app.trait("account", "a member starts signed in with GitHub", function* ({ auth }) {
+  const { cookies } = yield* Effect.promise(() => signedInUser(auth, {
+    email: "member@example.test",
+    name: "Member",
+    providerAccounts: [{ providerId: "github", accountId: "123" }],
+  }));
+  yield* seedCookies(cookies);
+});
+
+app.it("the member's provider account stores no credentials", [member], function* ({ session, story }) {
+  const { user } = yield* session();
+  const accounts = yield* Effect.promise(() => storedProviderAccounts(story.engine.auth, user.id));
+  expect(accounts).toEqual([{
+    providerId: "github",
+    accountId: "123",
+    hasAccessToken: false,
+    hasRefreshToken: false,
+    hasIdToken: false,
+    hasPassword: false,
+  }]);
+});
+```
 
 With database-backed sessions and cookie caching disabled, revocation rejects that same minted session on the next protected HTTP or RPC request. Cookie caching and secondary storage can change revocation timing.
 
@@ -755,7 +828,7 @@ Import the module that defines the name; there is no package-root entry. Paths b
 | `server/redactingDiagnostics.ts`, `server/redactingTracer.ts`, `server/redactingRpcSerialization.ts` | `redactingDiagnostics(sensitive)`, `redactRecord(values, sensitive)`, `redactingTracer(sensitive)`, `redactingRpcSerialization(wire, sensitive)`: compose native diagnostic and NDJSON boundaries. |
 | `server/runtime/makePlatform.ts` | `makePlatformRuntime(layer, { developmentCacheKey? })`. |
 | `server/node-http/subscriptionSignal.ts` | `nodeSubscriptionSignal({ nodeRequest?, request?, signals? })`, returning `{ signal, dispose }`. |
-| `server/better-auth/mount.ts` | `betterAuthMount(options, { signIn? })`, returning `{ auth, routes, admittedSessions, revokeUnadmitted }`, and `authDatabase(url)`: native auth routes, the sign-in policy and a scoped PostgreSQL pool. |
+| `server/better-auth/mount.ts` | `betterAuthMount(options, { signIn? })`, returning `{ auth, routes, admittedSessions, revokeUnadmitted }`, and `authDatabase(url, { max?, application_name? }?)`: native auth routes, the sign-in policy and a scoped PostgreSQL pool. |
 | `server/better-auth/allowedAccounts.ts` | `AllowedAccounts`, `allowedAccounts`: the provider-account list Schema and its `AUTH_ALLOWED_ACCOUNTS` Config. |
 | `server/better-auth/signInGate.ts` | `SignInPolicy`: the `accounts`, `rule` and `recheckInterval` of a sign-in policy. |
 | `server/better-auth/revokeUnadmitted.ts` | `RevokedSessions`: the `{ users, sessions }` counts of a revocation. |

package/dist/http-client/body.d.ts

@@ -0,0 +1,7 @@
+import { Effect, Schema } from "effect";
+import type { HttpClientResponse } from "effect/http";
+import { ResponseBodyTooLarge } from "./errors.ts";
+export declare const readBoundedBody: (response: HttpClientResponse.HttpClientResponse, limit: number) => Effect.Effect<Uint8Array<ArrayBuffer>, import("effect/http/HttpClientError").HttpClientError | ResponseBodyTooLarge, never>;
+export declare function readBoundedText(response: HttpClientResponse.HttpClientResponse, limit: number): Effect.Effect<string, import("effect/http/HttpClientError").HttpClientError | ResponseBodyTooLarge, never>;
+export declare function readBoundedJson<TSchema extends Schema.Constraint>(response: HttpClientResponse.HttpClientResponse, limit: number, schema: TSchema): Effect.Effect<TSchema["Type"], import("effect/http/HttpClientError").HttpClientError | ResponseBodyTooLarge | Schema.SchemaError, TSchema["DecodingServices"]>;
+//# sourceMappingURL=body.d.ts.map

package/dist/http-client/body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/http-client/body.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,eAAO,MAAM,eAAe,iMAwB1B,CAAC;AAEH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB,EAAE,KAAK,EAAE,MAAM,8GAE7F;AAED,wBAAgB,eAAe,CAAC,OAAO,SAAS,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,kKAEjJ"}

package/dist/http-client/body.js

@@ -0,0 +1,32 @@
+import { Effect, Schema, Stream } from "effect";
+import { ResponseBodyTooLarge } from "./errors.js";
+export const readBoundedBody = Effect.fnUntraced(function* (response, limit) {
+    const length = response.headers["content-length"];
+    if (length !== undefined && Number(length) > limit) {
+        return yield* new ResponseBodyTooLarge({ limit });
+    }
+    const chunks = [];
+    let size = 0;
+    yield* response.stream.pipe(Stream.runForEach((chunk) => {
+        size += chunk.byteLength;
+        if (size > limit) {
+            return Effect.fail(new ResponseBodyTooLarge({ limit }));
+        }
+        chunks.push(chunk);
+        return Effect.void;
+    }));
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+});
+export function readBoundedText(response, limit) {
+    return Effect.map(readBoundedBody(response, limit), (bytes) => new TextDecoder().decode(bytes));
+}
+export function readBoundedJson(response, limit, schema) {
+    return Effect.flatMap(readBoundedText(response, limit), Schema.decodeUnknownEffect(Schema.fromJsonString(schema)));
+}
+//# sourceMappingURL=body.js.map

package/dist/http-client/body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.js","sourceRoot":"","sources":["../../src/http-client/body.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,QAA+C,EAAE,KAAa;IACzH,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAClD,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC;QACpD,OAAO,KAAK,CAAC,CAAC,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;IACD,MAAM,MAAM,GAAiB,EAAE,CAAC;IAChC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAC1B,MAAM,CAAC,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;QAC3B,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC;QACzB,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC;YAClB,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO,MAAM,CAAC,IAAI,CAAC;IACpB,CAAC,CAAC,CACF,CAAC;IACF,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC;IAC5B,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC,CAAC,CAAC;AAEH,MAAM,UAAU,eAAe,CAAC,QAA+C,EAAE,KAAa;IAC7F,OAAO,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACjG,CAAC;AAED,MAAM,UAAU,eAAe,CAAoC,QAA+C,EAAE,KAAa,EAAE,MAAe;IACjJ,OAAO,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AACpH,CAAC"}

package/dist/http-client/errors.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+declare const RemoteUnauthorized_base: Schema.Class<RemoteUnauthorized, Schema.TaggedStruct<"RemoteUnauthorized", {
+    method: Schema.String;
+    status: Schema.Number;
+    url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteUnauthorized extends RemoteUnauthorized_base {
+}
+declare const RemoteNotFound_base: Schema.Class<RemoteNotFound, Schema.TaggedStruct<"RemoteNotFound", {
+    method: Schema.String;
+    status: Schema.Number;
+    url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteNotFound extends RemoteNotFound_base {
+}
+declare const RemoteGone_base: Schema.Class<RemoteGone, Schema.TaggedStruct<"RemoteGone", {
+    method: Schema.String;
+    status: Schema.Number;
+    url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteGone extends RemoteGone_base {
+}
+declare const RemoteRateLimited_base: Schema.Class<RemoteRateLimited, Schema.TaggedStruct<"RemoteRateLimited", {
+    readonly method: Schema.String;
+    readonly status: Schema.Number;
+    readonly url: Schema.String;
+    readonly retryAfter: Schema.optionalKey<Schema.DateTimeUtc>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteRateLimited extends RemoteRateLimited_base {
+}
+declare const RemoteHttpError_base: Schema.Class<RemoteHttpError, Schema.TaggedStruct<"RemoteHttpError", {
+    method: Schema.String;
+    status: Schema.Number;
+    url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RemoteHttpError extends RemoteHttpError_base {
+}
+export type RemoteStatusError = RemoteUnauthorized | RemoteNotFound | RemoteGone | RemoteRateLimited | RemoteHttpError;
+declare const PaginationLinkError_base: Schema.Class<PaginationLinkError, Schema.TaggedStruct<"PaginationLinkError", {
+    readonly reason: Schema.Literals<readonly ["cross-origin", "invalid"]>;
+    readonly url: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PaginationLinkError extends PaginationLinkError_base {
+}
+declare const ResponseBodyTooLarge_base: Schema.Class<ResponseBodyTooLarge, Schema.TaggedStruct<"ResponseBodyTooLarge", {
+    readonly limit: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResponseBodyTooLarge extends ResponseBodyTooLarge_base {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/http-client/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/http-client/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;;AAIhC,qBAAa,kBAAmB,SAAQ,uBAAsE;CAAG;;;;;;AACjH,qBAAa,cAAe,SAAQ,mBAA8D;CAAG;;;;;;AACrG,qBAAa,UAAW,SAAQ,eAAsD;CAAG;;;;;;;AACzF,qBAAa,iBAAkB,SAAQ,sBAGrC;CAAG;;;;;;AACL,qBAAa,eAAgB,SAAQ,oBAAgE;CAAG;AAExG,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,GAAG,cAAc,GAAG,UAAU,GAAG,iBAAiB,GAAG,eAAe,CAAC;;;;;AAEvH,qBAAa,mBAAoB,SAAQ,wBAGvC;CAAG;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAExC;CAAG"}

package/dist/http-client/errors.js

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+const answer = { method: Schema.String, status: Schema.Number, url: Schema.String };
+export class RemoteUnauthorized extends Schema.TaggedError()("RemoteUnauthorized", answer) {
+}
+export class RemoteNotFound extends Schema.TaggedError()("RemoteNotFound", answer) {
+}
+export class RemoteGone extends Schema.TaggedError()("RemoteGone", answer) {
+}
+export class RemoteRateLimited extends Schema.TaggedError()("RemoteRateLimited", {
+    ...answer,
+    retryAfter: Schema.optionalKey(Schema.DateTimeUtc),
+}) {
+}
+export class RemoteHttpError extends Schema.TaggedError()("RemoteHttpError", answer) {
+}
+export class PaginationLinkError extends Schema.TaggedError()("PaginationLinkError", {
+    reason: Schema.Literals(["cross-origin", "invalid"]),
+    url: Schema.String,
+}) {
+}
+export class ResponseBodyTooLarge extends Schema.TaggedError()("ResponseBodyTooLarge", {
+    limit: Schema.Number,
+}) {
+}
+//# sourceMappingURL=errors.js.map

package/dist/http-client/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/http-client/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAEpF,MAAM,OAAO,kBAAmB,SAAQ,MAAM,CAAC,WAAW,EAAsB,CAAC,oBAAoB,EAAE,MAAM,CAAC;CAAG;AACjH,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,EAAkB,CAAC,gBAAgB,EAAE,MAAM,CAAC;CAAG;AACrG,MAAM,OAAO,UAAW,SAAQ,MAAM,CAAC,WAAW,EAAc,CAAC,YAAY,EAAE,MAAM,CAAC;CAAG;AACzF,MAAM,OAAO,iBAAkB,SAAQ,MAAM,CAAC,WAAW,EAAqB,CAAC,mBAAmB,EAAE;IACnG,GAAG,MAAM;IACT,UAAU,EAAE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC;CAClD,CAAC;CAAG;AACL,MAAM,OAAO,eAAgB,SAAQ,MAAM,CAAC,WAAW,EAAmB,CAAC,iBAAiB,EAAE,MAAM,CAAC;CAAG;AAIxG,MAAM,OAAO,mBAAoB,SAAQ,MAAM,CAAC,WAAW,EAAuB,CAAC,qBAAqB,EAAE;IACzG,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;IACpD,GAAG,EAAE,MAAM,CAAC,MAAM;CAClB,CAAC;CAAG;AAEL,MAAM,OAAO,oBAAqB,SAAQ,MAAM,CAAC,WAAW,EAAwB,CAAC,sBAAsB,EAAE;IAC5G,KAAK,EAAE,MAAM,CAAC,MAAM;CACpB,CAAC;CAAG"}

package/dist/http-client/filterStatus.d.ts

@@ -0,0 +1,4 @@
+import { HttpClient } from "effect/http";
+import { type RemoteStatusError } from "./errors.ts";
+export declare function filterStatus<E, R>(client: HttpClient.HttpClient.With<E, R>): HttpClient.HttpClient.With<E | RemoteStatusError, R>;
+//# sourceMappingURL=filterStatus.d.ts.map

package/dist/http-client/filterStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterStatus.d.ts","sourceRoot":"","sources":["../../src/http-client/filterStatus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAA2B,MAAM,aAAa,CAAC;AAClE,OAAO,EAAkE,KAAK,iBAAiB,EAAsB,MAAM,aAAa,CAAC;AAiCzI,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,iBAAiB,EAAE,CAAC,CAAC,CAEjI"}

package/dist/http-client/filterStatus.js

@@ -0,0 +1,38 @@
+import { DateTime, Effect } from "effect";
+import { HttpClient } from "effect/http";
+import { RemoteGone, RemoteHttpError, RemoteNotFound, RemoteRateLimited, RemoteUnauthorized } from "./errors.js";
+import { parseRetryAfter } from "./parseRetryAfter.js";
+const checkStatus = Effect.fnUntraced(function* (response) {
+    const { status, request } = response;
+    if (status >= 200 && status < 300) {
+        return response;
+    }
+    const fields = { method: request.method, status, url: request.url.split(/[?#]/u)[0] ?? request.url };
+    let error;
+    switch (status) {
+        case 401:
+            error = new RemoteUnauthorized(fields);
+            break;
+        case 404:
+            error = new RemoteNotFound(fields);
+            break;
+        case 410:
+            error = new RemoteGone(fields);
+            break;
+        default: {
+            const header = response.headers["retry-after"];
+            if (status === 429 || (status === 503 && header !== undefined)) {
+                const retryAfter = parseRetryAfter(header, yield* DateTime.now);
+                error = new RemoteRateLimited({ ...fields, ...(retryAfter === undefined ? {} : { retryAfter }) });
+            }
+            else {
+                error = new RemoteHttpError(fields);
+            }
+        }
+    }
+    return yield* Effect.fail(error);
+});
+export function filterStatus(client) {
+    return HttpClient.transformResponse(client, Effect.flatMap(checkStatus));
+}
+//# sourceMappingURL=filterStatus.js.map

package/dist/http-client/filterStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterStatus.js","sourceRoot":"","sources":["../../src/http-client/filterStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,EAAE,UAAU,EAA2B,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAA0B,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACzI,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,QAA+C;IAC/F,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAC;IACrC,IAAI,MAAM,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG,EAAE,CAAC;QACnC,OAAO,QAAQ,CAAC;IACjB,CAAC;IACD,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACrG,IAAI,KAAwB,CAAC;IAC7B,QAAQ,MAAM,EAAE,CAAC;QAChB,KAAK,GAAG;YACP,KAAK,GAAG,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC;YACvC,MAAM;QACP,KAAK,GAAG;YACP,KAAK,GAAG,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC;YACnC,MAAM;QACP,KAAK,GAAG;YACP,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;YAC/B,MAAM;QACP,SAAS,CAAC;YACT,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YAC/C,IAAI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,SAAS,CAAC,EAAE,CAAC;gBAChE,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAChE,KAAK,GAAG,IAAI,iBAAiB,CAAC,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;YACnG,CAAC;iBAAM,CAAC;gBACP,KAAK,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;YACrC,CAAC;QACF,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC,CAAC,CAAC;AAEH,MAAM,UAAU,YAAY,CAAO,MAAwC;IAC1E,OAAO,UAAU,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;AAC1E,CAAC"}

package/dist/http-client/nextLink.d.ts

@@ -0,0 +1,2 @@
+export declare function nextLink(header: string | undefined): string | undefined;
+//# sourceMappingURL=nextLink.d.ts.map

package/dist/http-client/nextLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextLink.d.ts","sourceRoot":"","sources":["../../src/http-client/nextLink.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASvE"}

package/dist/http-client/nextLink.js

@@ -0,0 +1,11 @@
+export function nextLink(header) {
+    for (const link of header?.matchAll(/<(?<url>[^>]*)>(?<parameters>(?:[^<",]|"(?:\\.|[^"\\])*")*)/gu) ?? []) {
+        const relation = link.groups?.parameters?.match(/(?:^|;)\s*rel\s*=\s*(?:"(?<quoted>[^"]*)"|(?<unquoted>[^;\s,]+))/iu);
+        const relations = relation?.groups?.quoted ?? relation?.groups?.unquoted;
+        if (relations?.toLowerCase().split(/\s+/u).includes("next")) {
+            return link.groups?.url;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=nextLink.js.map

package/dist/http-client/nextLink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextLink.js","sourceRoot":"","sources":["../../src/http-client/nextLink.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,QAAQ,CAAC,MAA0B;IAClD,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,QAAQ,CAAC,+DAA+D,CAAC,IAAI,EAAE,EAAE,CAAC;QAC5G,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,oEAAoE,CAAC,CAAC;QACtH,MAAM,SAAS,GAAG,QAAQ,EAAE,MAAM,EAAE,MAAM,IAAI,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;QACzE,IAAI,SAAS,EAAE,WAAW,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7D,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC;QACzB,CAAC;IACF,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC"}

package/dist/http-client/paginate.d.ts

@@ -0,0 +1,5 @@
+import { Stream } from "effect";
+import { type HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/http";
+import { PaginationLinkError } from "./errors.ts";
+export declare function paginate<E, R>(client: HttpClient.HttpClient.With<E, R>, first: HttpClientRequest.HttpClientRequest): Stream.Stream<HttpClientResponse.HttpClientResponse, E | PaginationLinkError, R>;
+//# sourceMappingURL=paginate.d.ts.map

package/dist/http-client/paginate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginate.d.ts","sourceRoot":"","sources":["../../src/http-client/paginate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,KAAK,UAAU,EAAE,iBAAiB,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAoBlD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,iBAAiB,oFAgBlH"}

package/dist/http-client/paginate.js

@@ -0,0 +1,31 @@
+import { Effect, Stream } from "effect";
+import { HttpClientRequest } from "effect/http";
+import { PaginationLinkError } from "./errors.js";
+import { nextLink } from "./nextLink.js";
+const nextRequest = Effect.fnUntraced(function* (response) {
+    const link = nextLink(response.headers.link);
+    if (link === undefined) {
+        return undefined;
+    }
+    const current = response.url || response.request.url;
+    const url = current.split(/[?#]/u)[0] ?? current;
+    const next = yield* Effect.try({
+        catch: () => new PaginationLinkError({ reason: "invalid", url }),
+        try: () => new URL(link, current),
+    });
+    if (next.origin !== new URL(current).origin) {
+        return yield* new PaginationLinkError({ reason: "cross-origin", url });
+    }
+    return HttpClientRequest.setUrl(response.request, next);
+});
+export function paginate(client, first) {
+    return Stream.unfold(first, (state) => Effect.gen(function* () {
+        const request = HttpClientRequest.isHttpClientRequest(state) ? state : yield* nextRequest(state);
+        if (request === undefined) {
+            return undefined;
+        }
+        const response = yield* client.execute(request);
+        return [response, response];
+    }));
+}
+//# sourceMappingURL=paginate.js.map

package/dist/http-client/paginate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginate.js","sourceRoot":"","sources":["../../src/http-client/paginate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAmB,iBAAiB,EAA2B,MAAM,aAAa,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,QAA+C;IAC/F,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC;IACrD,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC;IACjD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;QAC9B,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,mBAAmB,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;QAChE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC;KACjC,CAAC,CAAC;IACH,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC;QAC7C,OAAO,KAAK,CAAC,CAAC,IAAI,mBAAmB,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACzD,CAAC,CAAC,CAAC;AAEH,MAAM,UAAU,QAAQ,CAAO,MAAwC,EAAE,KAA0C;IAClH,OAAO,MAAM,CAAC,MAAM,CAKlB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAClB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,MAAM,OAAO,GAAG,iBAAiB,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACjG,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAU,CAAC;IACtC,CAAC,CAAC,CACF,CAAC;AACH,CAAC"}

package/dist/http-client/parseRetryAfter.d.ts

@@ -0,0 +1,3 @@
+import { DateTime } from "effect";
+export declare function parseRetryAfter(header: string | undefined, now: DateTime.Utc): DateTime.Utc | undefined;
+//# sourceMappingURL=parseRetryAfter.d.ts.map

package/dist/http-client/parseRetryAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRetryAfter.d.ts","sourceRoot":"","sources":["../../src/http-client/parseRetryAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAU,MAAM,QAAQ,CAAC;AAI1C,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,GAAG,QAAQ,CAAC,GAAG,GAAG,SAAS,CAYvG"}

package/dist/http-client/parseRetryAfter.js

@@ -0,0 +1,17 @@
+import { DateTime, Option } from "effect";
+const httpDate = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT$/u;
+export function parseRetryAfter(header, now) {
+    if (header === undefined) {
+        return undefined;
+    }
+    const value = header.trim();
+    let millis = Number.NaN;
+    if (/^\d+$/u.test(value)) {
+        millis = DateTime.toEpochMillis(now) + Number(value) * 1000;
+    }
+    else if (httpDate.test(value)) {
+        millis = Date.parse(value);
+    }
+    return Option.getOrUndefined(DateTime.make(millis));
+}
+//# sourceMappingURL=parseRetryAfter.js.map

package/dist/http-client/parseRetryAfter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRetryAfter.js","sourceRoot":"","sources":["../../src/http-client/parseRetryAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE1C,MAAM,QAAQ,GAAG,qFAAqF,CAAC;AAEvG,MAAM,UAAU,eAAe,CAAC,MAA0B,EAAE,GAAiB;IAC5E,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC;IACxB,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAC7D,CAAC;SAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AACrD,CAAC"}

package/dist/rpc/publicConfig.d.ts

@@ -1,13 +1,9 @@
 import type { Schema } from "effect";
 export declare function publicConfig<T, E>(schema: Schema.Codec<T, E>): import("@shivaedev/effect-contract/contract.ts").Contract<"platform.publicConfig", readonly [NoInfer<import("@shivaedev/effect-contract/operation.ts").Query<"get", Schema.Void, Schema.Codec<T, E, never, never>, {}>>], readonly [], import("effect/rpc/Rpc").Rpc<"platform.publicConfig.get", Schema.Void, Schema.Codec<T, E, never, never>, Schema.Never, never, never> | import("effect/rpc/Rpc").Rpc<"platform.publicConfig.$changes", Schema.Struct<{
-    keys: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly _tag: Schema.Literal<"List">;
-        readonly collection: Schema.String;
-    }>, Schema.Struct<{
-        readonly _tag: Schema.Literal<"Item">;
-        readonly collection: Schema.String;
-        readonly id: Schema.Union<readonly [Schema.String, Schema.Number]>;
-    }>]>>;
+    queries: Schema.$Array<Schema.Union<readonly Schema.Struct<{
+        query: Schema.Literal<"get">;
+        payload: Schema.Void;
+    }>[]>>;
 }>, import("effect/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.Struct<{
     readonly _tag: Schema.Literal<"Changed">;
     readonly keys: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
@@ -20,5 +16,5 @@ export declare function publicConfig<T, E>(schema: Schema.Codec<T, E>): import("
     }>]>>;
 }>, Schema.Struct<{
     readonly _tag: Schema.Literal<"Resync">;
-}>]>, Schema.Never>, Schema.Never, never, never>, readonly []>;
+}>]>, Schema.Never>, Schema.Never, never, never>, readonly [], undefined>;
 //# sourceMappingURL=publicConfig.d.ts.map

package/dist/rpc/publicConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publicConfig.d.ts","sourceRoot":"","sources":["../../src/rpc/publicConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;+DAI5D"}
+{"version":3,"file":"publicConfig.d.ts","sourceRoot":"","sources":["../../src/rpc/publicConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;0EAI5D"}

package/dist/server/MigrationOptions.d.ts

@@ -7,6 +7,8 @@ export interface MigrationOptions<R = never> {
     readonly lockTimeout?: Duration.Input;
     readonly mode?: "migrate" | "check" | "wait";
     readonly pollInterval?: Duration.Input;
+    readonly progressInterval?: Duration.Input;
+    readonly release?: string;
     readonly table?: string;
     readonly waitTimeout?: Duration.Input;
 }

package/dist/server/MigrationOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MigrationOptions.d.ts","sourceRoot":"","sources":["../../src/server/MigrationOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAEhF,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,KAAK;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CACtC"}
+{"version":3,"file":"MigrationOptions.d.ts","sourceRoot":"","sources":["../../src/server/MigrationOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAEhF,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,KAAK;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACpC,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IAC7C,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IACvC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CACtC"}

package/dist/server/appHost.d.ts

@@ -8,7 +8,7 @@ import type { MigrationOptions } from "#server/MigrationOptions.ts";
 import type { SessionPolicy, SessionShape } from "#server/rpc-server/session.ts";
 declare const AppChanges_base: Context.ServiceClass<AppChanges, "@shivaedev/platform/AppChanges", {
     resync: Effect.Effect<void, never, never>;
-    stream: (keys: readonly import("@shivaedev/effect-contract/keys.ts").Key[]) => import("effect/Stream").Stream<{
+    stream: (keys: readonly import("@shivaedev/effect-contract/keys.ts").Key[], context?: import("@shivaedev/effect-contract/keys.ts").KeyContext) => import("effect/Stream").Stream<{
         readonly _tag: "Changed";
         readonly keys: readonly ({
             readonly _tag: "List";

package/dist/server/better-auth/mount.d.ts

@@ -1,7 +1,7 @@
 import { type BetterAuthOptions } from "better-auth";
 import { Config, Effect, Redacted } from "effect";
 import { HttpRouter } from "effect/http";
-import { Pool } from "pg";
+import { Pool, type PoolConfig } from "pg";
 import { type RevokeUnadmitted } from "#server/better-auth/revokeUnadmitted.ts";
 import { type SignInPolicy } from "#server/better-auth/signInGate.ts";
 import type { GetSession } from "#server/rpc-server/adapters/betterAuthSessions.ts";
@@ -247,5 +247,5 @@ export declare const betterAuthMount: <const TOptions extends BetterAuthOptions,
     revokeUnadmitted: RevokeUnadmitted<E>;
     routes: import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter>;
 }, Config.ConfigError, R>;
-export declare const authDatabase: (url: Redacted.Redacted<string>) => Effect.Effect<Pool, never, import("effect/Scope").Scope>;
+export declare const authDatabase: (url: Redacted.Redacted<string>, options?: Pick<PoolConfig, "application_name" | "max"> | undefined) => Effect.Effect<Pool, never, import("effect/Scope").Scope>;
 //# sourceMappingURL=mount.d.ts.map

package/dist/server/better-auth/mount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount.d.ts","sourceRoot":"","sources":["../../../src/server/better-auth/mount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,IAAI,EAAmB,MAAM,IAAI,CAAC;AAC3C,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,yCAAyC,CAAC;AAClG,OAAO,EAAsB,KAAK,YAAY,EAAc,MAAM,mCAAmC,CAAC;AAEtG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAGpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAA0D,QAAQ,SAAS,iBAAiB,EAAE,CAAC,UAAU,CAAC;uBAsD3G,QAAQ,SAAS,YAAY,cAAc,UAAU,CAAC,QAAQ,CAAC,KAAG,UAAU,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0B/G,CAAC;AAEH,eAAO,MAAM,YAAY,8FAqBvB,CAAC"}
+{"version":3,"file":"mount.d.ts","sourceRoot":"","sources":["../../../src/server/better-auth/mount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAc,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAU,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,IAAI,EAAmB,KAAK,UAAU,EAAE,MAAM,IAAI,CAAC;AAC5D,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,yCAAyC,CAAC;AAClG,OAAO,EAAsB,KAAK,YAAY,EAAc,MAAM,mCAAmC,CAAC;AAEtG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mDAAmD,CAAC;AAGpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAA0D,QAAQ,SAAS,iBAAiB,EAAE,CAAC,UAAU,CAAC;uBAsD3G,QAAQ,SAAS,YAAY,cAAc,UAAU,CAAC,QAAQ,CAAC,KAAG,UAAU,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0B/G,CAAC;AAEH,eAAO,MAAM,YAAY,kKAwBvB,CAAC"}

package/dist/server/better-auth/mount.js

@@ -71,11 +71,11 @@ export const betterAuthMount = Effect.fn("Platform.betterAuthMount")(function* (
     const revoke = Effect.provideContext(revokeUnadmitted(gate, () => auth.$context), context);
     return { admittedSessions, auth, revokeUnadmitted: revoke, routes };
 });
-export const authDatabase = Effect.fn("Platform.authDatabase")(function* (url) {
+export const authDatabase = Effect.fn("Platform.authDatabase")(function* (url, options = {}) {
     const clients = new Set();
     const run = Effect.runForkWith(yield* Effect.context());
     return yield* Effect.acquireRelease(Effect.sync(() => {
-        const pool = new Pool({ connectionString: Redacted.value(url) });
+        const pool = new Pool({ ...options, connectionString: Redacted.value(url) });
         pool.on("connect", (client) => clients.add(client));
         pool.on("remove", (client) => clients.delete(client));
         pool.on("error", (error) => {