@prisma/composer-prisma-cloud 0.1.0 → 0.2.0

package/dist/control.d.mts

@@ -1,56 +1,70 @@
-import * as Layer from "effect/Layer";
+import { t as ProviderParamEntry } from "./serializer-Cx5slrV4-xJfH6EWS.mjs";
 import { createManagementApiClient } from "@prisma/management-api-sdk";
-import { Resource, StackServices } from "alchemy";
-import { State, StateStoreError } from "alchemy/State";
-import postgres from "postgres";
-import { ExtensionDescriptor } from "@prisma/composer/config";
-
-//#region ../../1-prisma-cloud/0-lowering/lowering/dist/index-KMA4UtwS.d.mts
+import "effect/Context";
+import "effect/Effect";
+import "effect/Layer";
+import "effect/Redacted";
+import "effect/Config";
+import "alchemy/Provider";
+import { Resource } from "alchemy";
+import "effect/Schedule";
+import * as Output from "alchemy/Output";
+import { ExtensionDescriptor, StateDescriptor } from "@prisma/composer/config";
+//#region ../../1-prisma-cloud/0-lowering/lowering/dist/compute.d.mts
 /** Every region Prisma Compute serves — the runtime source of truth; `ComputeRegion` is derived from it so the two can never drift. */
 declare const COMPUTE_REGIONS: readonly ["us-east-1", "us-west-1", "eu-west-3", "eu-central-1", "ap-northeast-1", "ap-southeast-1"];
 type ComputeRegion = (typeof COMPUTE_REGIONS)[number];
 //#endregion
-//#region ../../1-prisma-cloud/0-lowering/lowering/dist/state/index.d.mts
-//#region src/state/layer.d.ts
+//#region ../../1-prisma-cloud/1-extensions/target/dist/control.d.mts
+//#region src/descriptors/shared.d.ts
 /**
- * The hosted Alchemy state store. On layer init (scoped, once per stack
- * run): find-or-create the workspace's `prisma-composer-state` project, mint a
- * fresh connection to its default database, migrate the schema, and
- * acquire the (stack, stage) advisory lock — see `bootstrap.ts` and
- * `lock.ts`. The Management API plumbing (`ManagementClient`,
- * `PrismaCredentials`) is provided internally, so the returned layer's
- * only requirements are the ones alchemy itself already provides to every
- * state store (`StackServices`).
+ * The provider-side reserved param for one brand's minted values (ADR-0031:
+ * "the provisioner owns mint, size, **aggregation**, stability, and
+ * rotation", and ADR-0019: the physical encoding is the target's). `value`
+ * is deploy-side: given every inbound edge's minted ref for one provider
+ * (possibly empty), it returns the typed value to store, or `undefined` to
+ * write no row. The returned value is encoded through the serializer's
+ * normal service-own literal path (JSON) — the same path any declared param
+ * takes — never a brand-invented wire format.
  *
- * Any bootstrap/lock/migration failure is wrapped into an operator-facing
- * `HostedStateBootstrapError` (naming the workspace and the step that
- * failed, never the raw driver/API error — see `errors.ts`) before dying the
- * layer (loud, immediate, unrecoverable) rather than surfacing as a typed
- * error — matching core's `LowerOptions.state: Layer.Layer<State, never,
- * StackServices>` contract and alchemy's own convention (e.g. a missing
- * state store is `Effect.die` in `Stack.make`).
- */
-declare const prismaState: (opts?: {
-  /** Defaults to the PRISMA_WORKSPACE_ID environment variable. */workspaceId?: string;
-}) => Layer.Layer<State, never, StackServices>; //#endregion
-//#region src/state/schema.d.ts
-/**
- * Idempotent schema migration for the Prisma-hosted state store — safe to run
- * on every deploy, since `create table if not exists` no-ops once the tables
- * exist. Run this against `sql` before serving a {@link StateService} built
- * by `makePrismaStateService` over the same client.
+ * This is the seam that keeps `descriptors/compute.ts` brand-blind: a
+ * `ProviderParam` is registered beside its brand's provisioner in
+ * `control.ts`; the descriptor asks every registered entry about every
+ * exposing service and writes whatever comes back.
  */
+interface ProviderParam extends ProviderParamEntry {
+  /**
+   * Every inbound edge's minted ref for this provider — POSSIBLY EMPTY. A
+   * provider with no wired consumers is still asked, because "no edges" and
+   * "no var" mean different things at boot: an absent var reads as "never
+   * provisioned" (local dev, tests). What an empty set means is this param's
+   * own call — deny everything, or emit nothing and let its reader fail closed.
+   */
+  readonly value: (refs: readonly unknown[]) => Output.Output<unknown> | unknown | undefined;
+}
 //#endregion
-//#region ../../1-prisma-cloud/1-extensions/target/dist/control.d.mts
-//#region src/control.d.ts
+//#region src/control/extension.d.ts
+/** The user-facing state descriptor: `state: prismaState()` in `prisma-composer.config.ts` (ADR-0017). */
+declare const prismaState: () => StateDescriptor;
 interface PrismaCloudOptions {
   /** Defaults to the PRISMA_WORKSPACE_ID environment variable. */
   workspaceId?: string;
   /** Defaults to the PRISMA_REGION environment variable when set. */
   region?: ComputeRegion;
 }
+/**
+ * Builds the deploy-side registry from the boot-side list, keyed by brand —
+ * throws if a boot-side entry has no registered deploy-side `value(refs)`, so
+ * `RESERVED_PROVIDER_PARAMS` stays the single source of which reserved
+ * provider params exist: deploy can no longer write a row boot never
+ * stashes. Exported (rather than inlined into `PROVIDER_PARAMS` below) so
+ * `__tests__/provider-params.test.ts` can drive it directly with a
+ * deliberately incomplete value map and watch it throw.
+ */
+declare function buildProviderParams(entries: readonly ProviderParamEntry[], values: ReadonlyMap<symbol, ProviderParam['value']>): ReadonlyMap<symbol, ProviderParam>;
+declare const PROVIDER_PARAMS: ReadonlyMap<symbol, ProviderParam>;
 /** The Prisma Cloud extension descriptor — `prisma-composer.config.ts` lists it under `extensions`. */
-declare const prismaCloud: (opts?: PrismaCloudOptions) => ExtensionDescriptor; //#endregion
+declare const prismaCloud: (opts?: PrismaCloudOptions) => ExtensionDescriptor;
 //#endregion
-export { PrismaCloudOptions, prismaCloud, prismaState };
+export { PROVIDER_PARAMS, PrismaCloudOptions, buildProviderParams, prismaCloud, prismaState };
 //# sourceMappingURL=control.d.mts.map