@prisma/composer-prisma-cloud 0.1.0 → 0.2.0-dev.2

package/dist/control.d.mts

@@ -1,56 +1,99 @@
-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`).
+ * 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;
+}
+/**
+ * The slice of compute's provisioned handoff a service-derived provider param
+ * may read. A minimal structural type, not `ComputeProvisioned` itself:
+ * shared.ts sits below `descriptors/compute.ts` in the import graph, so
+ * naming the full type here would invert it.
  */
-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
+interface ServiceProvisionedAttributes {
+  readonly endpointDomain: Output.Output<string | undefined>;
+}
 /**
- * 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.
+ * A reserved provider param whose value derives from the provider service's
+ * OWN provisioned attributes rather than its inbound edges — the
+ * service-derived sibling of `ProviderParam` (e.g. the service's own origin).
+ * Asked for EVERY compute service, exposing or not: a service needs no
+ * consumers to have an origin, so the descriptor's expose check applies only
+ * to edge-derived entries. Like `ProviderParam.value`, the return is encoded
+ * through the serializer's normal service-own literal path (JSON) by the
+ * descriptor's generic loop, never here.
  */
+interface ServiceProviderParam extends ProviderParamEntry {
+  readonly valueForService: (provisioned: ServiceProvisionedAttributes, address: string) => 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;
 }
+/**
+ * One brand's deploy-side value registration: edge-derived (`value(refs)`,
+ * fed by the provider's inbound edges) or service-derived
+ * (`valueForService(provisioned, address)`, fed by the service's own
+ * provisioned attributes).
+ */
+type ProviderParamValue = Pick<ProviderParam, 'value'> | Pick<ServiceProviderParam, 'valueForService'>;
+/**
+ * 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 function,
+ * 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, ProviderParamValue>): ReadonlyMap<symbol, ProviderParam | ServiceProviderParam>;
+declare const PROVIDER_PARAMS: ReadonlyMap<symbol, ProviderParam | ServiceProviderParam>;
 /** 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, ProviderParamValue, buildProviderParams, prismaCloud, prismaState };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../../../1-prisma-cloud/0-lowering/lowering/dist/compute.d.mts","../../../1-prisma-cloud/1-extensions/target/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;cAkDc;KACT,wBAAwB;;;;;;;;;;;;;;;;;;;UC/BnB,sBAAsB;;;;;;;;WAQrB,QAAQ,6BAA6B,OAAO;;;;;;;;UAQ7C;WACC,gBAAgB,OAAO;;;;;;;;;;;;UAYxB,6BAA6B;WAC5B,kBAAkB,aAAa,8BAA8B,oBAAoB,OAAO;;;;;cAKrF,mBAAmB;UACvB;;EAER;;EAEA,SAAS;;;;;;;;KAQN,qBAAqB,KAAK,0BAA0B,KAAK;;;;;;;;;;iBAU7C,oBAAoB,kBAAkB,sBAAsB,QAAQ,oBAAoB,sBAAsB,oBAAoB,gBAAgB;cACrJ,iBAAiB,oBAAoB,gBAAgB;;cAErD,cAAc,OAAO,uBAAuB"}