@prisma/composer-prisma-cloud 0.1.0-dev.9 → 0.2.0-dev.1

package/dist/control.d.mts

@@ -1,45 +1,20 @@
 import { t as ProviderParamEntry } from "./serializer-Cx5slrV4-xJfH6EWS.mjs";
-import * as Layer from "effect/Layer";
 import { createManagementApiClient } from "@prisma/management-api-sdk";
 import "effect/Context";
 import "effect/Effect";
+import "effect/Layer";
 import "effect/Redacted";
 import "effect/Config";
 import "alchemy/Provider";
-import { Resource, StackServices } from "alchemy";
+import { Resource } from "alchemy";
 import "effect/Schedule";
-import postgres from "postgres";
-import { State, StateStoreError } from "alchemy/State";
 import * as Output from "alchemy/Output";
-import { ExtensionDescriptor } from "@prisma/composer/config";
+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.d.mts
-//#endregion
-//#region src/state/layer.d.ts
-/**
- * The hosted Alchemy state store. On layer init (scoped, once per stack
- * run): resolve the stage's Branch, find-or-create its `prisma-composer-state`
- * database, create a fresh connection, 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`).
- *
- * Any bootstrap/lock/migration failure is wrapped into an operator-facing
- * `HostedStateBootstrapError` (naming the Project/Branch 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: () => Layer.Layer<State, never, StackServices>;
-//#endregion
 //#region ../../1-prisma-cloud/1-extensions/target/dist/control.d.mts
 //#region src/descriptors/shared.d.ts
 /**
@@ -67,27 +42,58 @@ interface ProviderParam extends ProviderParamEntry {
    */
   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.
+ */
+interface ServiceProvisionedAttributes {
+  readonly endpointDomain: Output.Output<string | undefined>;
+}
+/**
+ * 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 src/exports/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(refs)`, so
- * `RESERVED_PROVIDER_PARAMS` stays the single source of which reserved
+ * 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, ProviderParam['value']>): ReadonlyMap<symbol, ProviderParam>;
-declare const PROVIDER_PARAMS: ReadonlyMap<symbol, ProviderParam>;
+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
-export { PROVIDER_PARAMS, PrismaCloudOptions, buildProviderParams, prismaCloud, prismaState };
+export { PROVIDER_PARAMS, PrismaCloudOptions, ProviderParamValue, buildProviderParams, prismaCloud, prismaState };
 //# sourceMappingURL=control.d.mts.map