@azure/provisioning-core 1.0.0-beta.1

package/dist/commonjs/constructs/resource/resource.d.ts

@@ -0,0 +1,460 @@
+import { ProvisioningComponent } from "../provisioning-component.js";
+import { type Expression, type ExpressionOrValue } from "../../expression/expressions.js";
+import type { ExpressionNode } from "../../expression/ast-nodes.js";
+import type { PropertySegment } from "../../types.js";
+import type { ResourceNamingRules } from "../../naming/naming-rules.js";
+import { RAW_RESOURCE_HANDLE, RESOURCE_BRAND, RESOURCE_DECLARATION_BRAND, LOOPED_RESOURCE_BRAND } from "./resource-proxy.js";
+import type { FlatModelShape } from "../../shape/shape.js";
+import { type ResourceCtor } from "./resource-registry.js";
+import type { FlatVariantSelector } from "./resource-type-registry.js";
+/**
+ * A Bicep `scope:` expression. Used on `existing` resource references for
+ * cross-RG / cross-subscription / cross-MG / cross-tenant lookups, and on
+ * modules to set the nested deployment scope.
+ *
+ * Typed as `Expression<unknown>` because the natural producers are the
+ * scope-function helpers in `fn` (`fn.resourceGroup(...)`,
+ * `fn.subscription(...)`, `fn.managementGroup(...)`, `fn.tenant()`), all
+ * of which return `Expression<TScope>` proxies. Narrowing further isn't
+ * worthwhile today since the set of acceptable scope-producing
+ * expressions isn't closed and Bicep validates the actual call shape
+ * downstream.
+ */
+export type ScopeExpression = Expression<unknown>;
+/**
+ * Internal representation used to construct resource handle objects.
+ * The proxy converts these into the public Resource shape.
+ */
+export interface ResourceState<TType extends string = string> {
+    name: ExpressionOrValue<string>;
+    readonly type: TType;
+    readonly apiVersion: string;
+    readonly existing?: boolean | undefined;
+    /**
+     * Optional Bicep `scope:` expression. Currently emitted only on `existing`
+     * resource references (e.g. `scope: resourceGroup('shared')` for a
+     * cross-RG lookup). Future scope-hoisted resource types may emit it on
+     * deployable resources too — for example, deploying a
+     * `Microsoft.Management/managementGroups` from a subscription-targeted
+     * file requires `scope: tenant()`. See `contributing/bicep/bicep-scope.md` section 2.2.
+     *
+     * For ordinary deployable resources this field is `undefined` — their
+     * deployment scope is determined by the file's `targetScope` (or by the
+     * containing `ResourceGroup` / module the resource lives in).
+     *
+     * Stored as a raw `ExpressionNode` (the user-facing `ScopeExpression`
+     * proxy is unwrapped at the constructor boundary, matching the
+     * "`state` holds normalized raw nodes" invariant that
+     * `normalizeAssignedValue` maintains for every other field).
+     */
+    readonly scope?: ExpressionNode | undefined;
+    readonly condition?: ExpressionOrValue<boolean> | undefined;
+}
+/**
+ * Public-facing props for a reference to an existing (pre-deployed) Azure
+ * resource. This is strictly narrower than the deployable resource props —
+ * Bicep `existing` declarations only accept `name` and optional `scope:`.
+ *
+ * Read-side access on the returned resource handle is unrestricted —
+ * `kv.properties.vaultUri`, `sa.id`, etc. all work and compile to symbolic
+ * references that ARM resolves at deployment time.
+ *
+ * Symbolic parent/extension scopes are expressed by passing the parent
+ * resource as the ProvisioningComponent `context` argument to the resource constructor
+ * (with `{ existing: true }`), not via this `scope` field.
+ */
+export interface ExistingResourceProps {
+    /** Required. The actual Azure name of the existing resource. */
+    readonly name: ExpressionOrValue<string>;
+    /**
+     * Optional. The scope at which to look up the resource. Used when the
+     * resource lives outside the current deployment's scope (different RG,
+     * subscription, management group, or tenant).
+     *
+     * Pass a scope-function call expression (e.g. `resourceGroup("name")`,
+     * `subscription()`, `managementGroup("mg")`, `tenant()`).
+     */
+    readonly scope?: ScopeExpression;
+}
+/**
+ * `ExistingResourceProps` for singleton child resources — `name` is omitted
+ * because singleton children have a fixed name (e.g. `"default"`).
+ */
+export type SingletonExistingResourceProps = Omit<ExistingResourceProps, "name">;
+/**
+ * Internal props accepted by the base `Resource` constructor. A loose
+ * superset of both the deployable and existing public shapes — the runtime
+ * constructor branches on `props.existing` to decide which fields are
+ * honored. Generated CDK resource classes expose a discriminated union
+ * `(Deployable & { existing?: false }) | (Existing & { existing: true })`;
+ * passing `{ ...existingProps, existing: true }` selects the existing arm and
+ * emits a Bicep `existing` reference instead of a new declaration.
+ */
+export interface ResourceProps<TType extends string> {
+    readonly name?: ExpressionOrValue<string> | undefined;
+    readonly apiVersion: string;
+    readonly type: TType;
+    readonly existing?: boolean;
+    /**
+     * Optional Bicep `scope:` value for an existing resource reference.
+     * Only honored when `existing === true`. Ignored on deployable resources
+     * (non-existing resources have no per-resource scope in Bicep).
+     */
+    readonly scope?: ScopeExpression;
+}
+/**
+ * Optional third-argument bag passed to every resource constructor. Holds
+ * authoring flags that affect how the resource declaration is emitted but are
+ * not ARM-modeled properties of the resource body.
+ *
+ * Fields:
+ * - `condition` — an `if(...)` guard on the declaration. A boolean
+ *   expression (typically produced by `fn.eq`, `fn.and`, etc.) or a
+ *   plain `boolean`. Bind it to a `const` to reuse the same predicate
+ *   across multiple resources.
+ *
+ * `existing` is deliberately **not** an option — it is the discriminant of
+ * the generated props union (`{ existing?: false } | { existing: true }`)
+ * and lives on `props`. Routing it through options too would allow
+ * contradictory settings between the two channels.
+ *
+ * `namingRules` is deliberately **not** an option either — it is
+ * per-resource-type metadata declared as a `protected static namingRules`
+ * field on each concrete `Resource` subclass and consumed by the base
+ * constructor reflectively, so it stays off the user-facing surface.
+ *
+ */
+export interface ResourceOptions {
+    readonly condition?: ExpressionOrValue<boolean>;
+    readonly dependsOn?: readonly ResourceDeclaration[];
+}
+/**
+ * Shared base for resource declaration implementations.
+ *
+ * @remarks
+ *
+ * Both represent one Bicep resource declaration in the component tree and
+ * share the same declaration-level state layout: identity fields
+ * (`type`, `apiVersion`, `existing`), the `if(...)` guard (`condition`),
+ * the optional cross-scope reference (`scope`), and the raw prop bag that
+ * becomes the resource body.
+ *
+ * This class owns the common declaration state layout, raw-handle escape
+ * hatch, and identity accessors. Subclasses supply their construction and
+ * access behavior.
+ */
+export declare abstract class ResourceDeclaration<TType extends string = string> extends ProvisioningComponent {
+    /**
+     * Brand marker for cross-realm `isResourceDeclaration()` checks. Uses
+     * `Symbol.for` so it survives multiple copies of `@azure/provisioning-core`.
+     * Inherited by every resource declaration implementation.
+     */
+    readonly [RESOURCE_DECLARATION_BRAND]: true;
+    protected state: ResourceState<TType> & Record<string, unknown>;
+    /**
+     * Base constructor for every Bicep resource declaration.
+     *
+     * @remarks
+     *
+     * Responsibilities:
+     * 1. Register in the component tree (`super(context)`).
+     * 2. Enforce a deployment context ancestor.
+     * 3. Unwrap `context` if it's an indexed proxy from `.at(i)` /
+     *    `parent.at(loop.index)`, and stash `parentIndex` on `state` so the
+     *    serializer can emit `parent: parentSym[index]` on the child.
+     * 4. Inherit `condition` from the immediate parent resource
+     *    declaration when the caller doesn't supply one (Bicep requires
+     *    children of a conditional resource to share the same guard).
+     * 5. Populate `state` — existing arm records only identity fields;
+     *    deployable arm runs the naming policy and applies
+     *    `DeploymentContext` defaults for `location` / `tags` per the
+     *    shape descriptor.
+     *
+     * Subclasses supply the last mile, including their public handle behavior.
+     *
+     * @param namingRules - per-resource-type constraints for the naming
+     *   policy. `Resource` reads this reflectively off the concrete subclass
+     *   constructor; internal declaration implementations receive it from
+     *   the concrete resource constructor they represent.
+     */
+    constructor(context: ProvisioningComponent, props: ResourceProps<TType> & Record<string, unknown>, options?: ResourceOptions, namingRules?: ResourceNamingRules);
+    /**
+     * Core-internal escape hatch: exposes the raw `state` backing object to
+     * the proxy layer (`resource-proxy.ts`) so it can read/unwrap the
+     * declaration's data across module boundaries. Keyed by the
+     * module-scoped {@link RAW_RESOURCE_HANDLE} symbol, which is **not**
+     * exported from `@azure/provisioning-core`, so package consumers can't name it.
+     *
+     * `protected` (not `private`) because the accessors that read it use
+     * `Reflect.get` / structural casts that bypass TS visibility anyway;
+     * the modifier just keeps it off the public type surface. It can't be a
+     * `#private` field because the proxy layer lives in a different class.
+     *
+     * @internal
+     */
+    protected get [RAW_RESOURCE_HANDLE](): ResourceState<TType> & Record<string, unknown>;
+    get type(): TType;
+    get apiVersion(): string;
+    get existing(): boolean | undefined;
+    get condition(): ExpressionOrValue<boolean> | undefined;
+    get dependsOn(): readonly ResourceDeclaration[] | undefined;
+    protected expr<TValue>(...path: readonly PropertySegment[]): Expression<TValue> & TValue;
+    protected setProperty(key: string, value: unknown): void;
+}
+/**
+ * Base class for all Azure resources.
+ *
+ * @remarks
+ * Resources are fully initialized at construction time. Pass a parent
+ * `ProvisioningComponent` (typically a `Stack` or `ResourceGroup`) as the first
+ * argument — the resource registers itself in the tree automatically.
+ *
+ * Properties use expression-backed proxies: reading `resource.name`
+ * returns an `Expression` that compiles to a Bicep symbolic reference,
+ * not a plain string. Use `this.expr()` in subclasses to create
+ * property getters and `this.setProperty()` for setters.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { ResourceGroup, Stack } from "@azure/provisioning-core";
+ * import { KeyVault } from "@azure/provisioning-keyvault";
+ *
+ * const stack = new Stack("my-app", { targetScope: "subscription" });
+ * const rg = new ResourceGroup(stack, { name: "rg-my-app", location: "eastus" });
+ * const vault = new KeyVault(rg, {
+ *   name: "kv-my-app",
+ *   properties: {
+ *     tenantId: "11111111-1111-1111-1111-111111111111",
+ *     sku: { family: "A", name: "standard" },
+ *   },
+ * });
+ *
+ * // vault.name is an Expression, not a string
+ * // vault.id compiles to resourceId(...)
+ * ```
+ */
+export declare class Resource<TType extends string = string> extends ResourceDeclaration<TType> {
+    /**
+     * Brand marker for cross-realm `isResource()` checks.
+     * Uses `Symbol.for` so it survives multiple copies of `@azure/provisioning-core`.
+     */
+    readonly [RESOURCE_BRAND]: true;
+    /**
+     * Register a {@link FlatModelShape} for this resource class's
+     * `(resourceType, apiVersion)` pair. Intended to be invoked from a
+     * `static {}` initializer in generated subclasses so the registration
+     * happens at module load.
+     *
+     * The static method reads `resourceType` and `apiVersion` off `this`
+     * (the subclass that called it), so callers don't repeat the literals.
+     */
+    static registerShape(this: {
+        readonly resourceType: string;
+        readonly apiVersion: string;
+    }, shape: FlatModelShape, variantSelector?: FlatVariantSelector): void;
+    /**
+     * Register this class with the global resource registry so the
+     * deserializer can reconstruct instances of it (instead of falling
+     * back to base `Resource`) for matching `(resourceType, apiVersion)`
+     * pairs. Intended to be invoked from a `static {}` initializer in
+     * generated classes alongside {@link Resource.registerShape}.
+     *
+     * Pass an ordered discriminator path for concrete resource variants. A
+     * singleton is one segment (`name=signin`); model-discriminated resources
+     * may use `kind` or several nested segments. Omit for ordinary resources.
+     */
+    protected static register(this: ResourceCtor, variantSelector?: FlatVariantSelector): void;
+    /**
+     * Assemble the base-`Resource` constructor payload (the second `super(...)`
+     * argument) from the user-facing props. This is a **static "virtual"**:
+     * it runs before an instance exists (to compute the `super` argument), so
+     * it can't be an instance method — but it still dispatches through the
+     * calling constructor, so a subclass's override wins.
+     *
+     * Every emitter-generated resource overrides this to inject its fixed
+     * identity (`type` / `apiVersion`), the singleton `name`, and its explicit
+     * writable-field copy. Both ordinary construction and internal resource
+     * reconstruction funnel through this method so prop shaping remains
+     * consistent.
+     *
+     * This base default is the fallback used when the wrapped constructor is
+     * base `Resource` itself — the deserialize path for an unregistered
+     * `(type, apiVersion)` pair, where `type` / `apiVersion` are threaded in
+     * through `props` rather than read off statics. Keeping the default here
+     * guarantees the method is always present for internal reconstruction.
+     */
+    protected static buildResourceProps(props?: unknown): ResourceProps<string> & Record<string, unknown>;
+    /**
+     * Per-resource-type naming constraints, consumed by the active
+     * {@link NamingPolicy} when a resource is created without an explicit
+     * `name`. Generated CDK subclasses override this with a concrete value;
+     * the base default of `undefined` yields `MOST_RESTRICTIVE` behavior.
+     *
+     * This is type metadata, not user input, so it is kept off the public
+     * props surface and read reflectively in the constructor via
+     * `this.constructor` rather than being threaded through `ResourceProps`.
+     */
+    protected static namingRules?: ResourceNamingRules;
+    protected _selfProxy: this | undefined;
+    constructor(context: ProvisioningComponent, props: ResourceProps<TType> & Record<string, unknown>, options?: ResourceOptions);
+    get self(): this;
+    /**
+     * The Azure resource name as a Bicep symbolic-reference expression.
+     *
+     * The value is established at construction time (either user-supplied
+     * via `props.name` or filled in by the naming policy) and stored on
+     * `state.name`. The setter routes through `setProperty` so post-
+     * construction edits flow through the same proxy/expression machinery
+     * as any other property — useful when working with a base `Resource`
+     * reference and re-binding the name dynamically. Singleton subclasses
+     * override this getter to narrow the return type to the literal
+     * `Expression<"<singletonName>">`; non-singleton subclasses inherit
+     * this accessor pair as-is.
+     */
+    get name(): Expression<string>;
+    set name(value: ExpressionOrValue<string>);
+    get id(): Expression<string>;
+}
+/**
+ * Metadata describing a Bicep `[for … in …]` loop and the concrete
+ * variable names used inside it. Stored publicly on {@link LoopedResource.loop}
+ * once a looped resource declaration has been created.
+ */
+export interface LoopContext {
+    readonly collection: unknown;
+    readonly itemVariable: string;
+    readonly indexVariable?: string;
+    readonly batchSize?: number;
+}
+/**
+ * Options accepted by `new Loop(collection, options?)`. All fields are
+ * optional overrides; the constructor supplies defaults. Derived from
+ * {@link LoopContext} so there is exactly one source of truth for the
+ * shape of loop metadata.
+ */
+export type LoopOptions = Partial<Omit<LoopContext, "collection">>;
+/**
+ * Describes a Bicep `[for item in collection: ...]` loop as a plain data
+ * object. Construct one and pass it to
+ * `Ctor.fromLoop(loop, context, props, options?)` (e.g.
+ * `StorageAccount.fromLoop(...)`) to expand a resource declaration into a
+ * resource-copy loop.
+ *
+ * The item and index variable names default to `item` / `i`. Bicep
+ * for-expressions bind their loop variables only within their own body,
+ * so two sibling `[for item in xs: …]` / `[for item in ys: …]` in the
+ * same file do **not** collide — each `item` is scoped to its own
+ * expression. If you nest a `Loop` inside another loop's body (rare),
+ * pass `{ itemVariable, indexVariable }` explicitly on the inner one to
+ * disambiguate. `batchSize` on the loop renders as `@batchSize(n)` on
+ * the resource that consumes it.
+ *
+ * The `indexVariable` name is always materialized on read (never
+ * `undefined`), but whether the wire actually **records** it — and
+ * therefore whether the renderer emits the `[for (item, i) in …]` tuple
+ * binding — is decided by whether anyone accessed `loop.index` (or the
+ * caller supplied `{ indexVariable }` explicitly). A loop whose body
+ * never mentions an index emits a bare `[for item in xs: …]`.
+ *
+ * `Loop` instances are pure data — creating one has no side effect.
+ */
+export declare class Loop<T> {
+    #private;
+    readonly collection: ExpressionOrValue<T[]>;
+    readonly itemVariable: string;
+    readonly item: Expression<T>;
+    readonly batchSize?: number;
+    constructor(collection: ExpressionOrValue<T[]>, options?: LoopOptions);
+    /**
+     * Name of the loop's index variable. Always defined — reading it
+     * materializes the default (`i`) if the caller neither passed
+     * `{ indexVariable }` nor accessed `.index` yet.
+     *
+     * Reading `.indexVariable` also marks the index as requested (same as
+     * reading `.index`), because a caller who wants the variable name is
+     * almost certainly going to use it. If the wire-omit optimization
+     * (bare `[for item in …]` with no index binding) matters, callers
+     * should gate on `.indexRequested` first before touching this getter.
+     */
+    get indexVariable(): string;
+    /**
+     * Expression referencing the current iteration's index. Reading this the
+     * first time marks the index as requested, which causes the wire to
+     * include `indexVariable` on the `for-expression` node and the renderer
+     * to emit `[for (item, i) in …]`. Callers who never touch `.index` get
+     * the cleaner index-less form.
+     */
+    get index(): Expression<number>;
+    /**
+     * Framework-internal signal used by `Resource.fromLoop` to decide
+     * whether the wire should include the index binding. `true` when the
+     * caller either supplied `{ indexVariable }` explicitly or has accessed
+     * `.index` / `.indexVariable` at least once. Not exported from
+     * `@azure/provisioning-core`.
+     *
+     * @internal
+     */
+    get indexRequested(): boolean;
+}
+/**
+ * A `LoopedResource<T>` represents a single Bicep resource declaration
+ * expanded across a loop (`[for x in xs: {...}]`). It is a real
+ * `ProvisioningComponent` in the tree — one node per emitted declaration — and
+ * exposes indexed access into individual iterations via
+ * {@link LoopedResource.at}.
+ *
+ * @remarks
+ *
+ * Property access on a `LoopedResource` is deliberately not exposed at
+ * the type level: pick an index (`at`) to obtain a proxy that emits
+ * `sym[i].prop`. This mirrors Bicep's requirement that individual
+ * iterations be accessed by index.
+ *
+ * `.at(i)` returns the concrete resource type `T`. The returned proxy
+ * exposes the essential ARM surface — the property getters/setters that
+ * funnel through `this.expr(...)` (`.id`, `.name`, `.sku`,
+ * `.properties.*`, …) rooted at `sym[i]` — as well as the child
+ * accessors (`keyVault.secrets`, singleton getter/setters), which are
+ * derived from the parent's `children` scoped to element `i`. To attach
+ * per-iteration children, parent them to `parent.at(loop.index)` — e.g.
+ * `Child.fromLoop(loop, parent.at(loop.index), ...)`.
+ *
+ * Projection over the loop (Bicep `map(sym, x => body)`) is tracked as
+ * a follow-up effort — see the "lambda + fn.map" issue.
+ */
+export declare class LoopedResource<T extends Resource = Resource> extends ResourceDeclaration<T["type"]> {
+    #private;
+    /**
+     * Cross-realm brand — same technique as the scalar `RESOURCE_BRAND`.
+     * Use {@link isLoopedResource} instead of `instanceof`
+     * when multiple copies of `@azure/provisioning-core` may be loaded.
+     */
+    readonly [LOOPED_RESOURCE_BRAND]: true;
+    /** Metadata describing the loop that produced this declaration. */
+    readonly loop: LoopContext;
+    private constructor();
+    /**
+     * The concrete `Resource` subclass this looped declaration wraps.
+     * Used by query machinery to answer "which subclass is this looped
+     * resource" — the analogue of `instanceof T` for `LoopedResource<T>`.
+     *
+     * This is always the full subclass the user constructed via
+     * `Xxx.fromLoop(...)` — query identity matches on that class, and it is
+     * the prototype the `.at(i)` proxy uses to resolve ARM accessors.
+     */
+    get wrappedCtor(): new (context: ProvisioningComponent, props: unknown, options?: ResourceOptions) => T;
+    /**
+     * Reference the element at `index`. Emits `sym[index].<...>` for
+     * subsequent property access.
+     *
+     * Returns the concrete resource type `T`. At runtime an indexed proxy is
+     * spliced over the full class prototype (`#wrappedCtor.prototype`):
+     * prototype getters that funnel through `this.expr(...)` (`.id`, `.name`,
+     * `.properties.*`, …) resolve rooted at `sym[index]`. A child created with
+     * `parent.at(i)` is stamped with that index for serialization.
+     */
+    at(index: ExpressionOrValue<number>): T;
+}
+/** @internal */
+export declare function createLoopedResource<T extends Resource, C extends ProvisioningComponent, P, Item>(wrappedCtor: new (context: C, props: P, options?: ResourceOptions) => T, loop: Loop<Item>, context: C, ...rest: undefined extends P ? [props?: P, options?: ResourceOptions] : [props: P, options?: ResourceOptions]): LoopedResource<T>;
+//# sourceMappingURL=resource.d.ts.map

package/dist/commonjs/constructs/resource/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../../src/constructs/resource/resource.ts"],"names":[],"mappings":"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"}