@quadnix/octo 0.0.30 → 0.2.0

package/dist/services/transaction/transaction.service.d.ts

@@ -4,45 +4,145 @@ import { type Diff } from '../../functions/diff/diff.js';
 import { ModuleContainer } from '../../modules/module.container.js';
 import { OverlayDataRepository } from '../../overlays/overlay-data.repository.js';
 import { ResourceDataRepository } from '../../resources/resource-data.repository.js';
-import { CaptureService } from '../capture/capture.service.js';
 import { EventService } from '../event/event.service.js';
 import { InputService } from '../input/input.service.js';
+import { ResourceSerializationService } from '../serialization/resource/resource-serialization.service.js';
+import { TerraformService } from '../terraform/terraform.service.js';
 /**
  * @internal
  */
 export declare class TransactionService {
-    private readonly captureService;
     private readonly eventService;
     private readonly inputService;
     private readonly moduleContainer;
     private readonly overlayDataRepository;
     private readonly resourceDataRepository;
+    private readonly resourceSerializationService;
+    private readonly terraformService;
     private modelActions;
     private overlayActions;
     private resourceActions;
-    constructor(captureService: CaptureService, eventService: EventService, inputService: InputService, moduleContainer: ModuleContainer, overlayDataRepository: OverlayDataRepository, resourceDataRepository: ResourceDataRepository);
+    /**
+     * @internal
+     */
+    constructor(eventService: EventService, inputService: InputService, moduleContainer: ModuleContainer, overlayDataRepository: OverlayDataRepository, resourceDataRepository: ResourceDataRepository, resourceSerializationService: ResourceSerializationService, terraformService: TerraformService);
+    /**
+     * Runs the delete action of every **external** resource in `resourceDiffs` that is being deleted.
+     *
+     * Terraform cannot do this. Octo deletes a resource by removing its block from the configuration,
+     * and terraform will not run a `when = destroy` provisioner for a resource that is no longer in
+     * the configuration - it drops the `null_resource` from state and moves on. So the callback that
+     * would have told an external resource to delete itself never fires, and the real thing it created
+     * outlives both state files with nothing tracking it.
+     *
+     * Octo knows the resource was deleted, which is why this can be driven from its own diff instead.
+     * {@link commit} calls it before recording anything, so a failed delete leaves octo state untouched
+     * and the deletion is retried on the next run rather than being forgotten.
+     *
+     * Terraform-managed resources are excluded: terraform destroys those itself, and a resource action
+     * on one is rejected everywhere else in octo.
+     *
+     * @returns The diffs whose actions ran, in the order they ran.
+     */
+    applyExternalResourceDeletes(resourceDiffs: DiffMetadata[][]): Promise<DiffMetadata[][]>;
+    /**
+     * @internal
+     */
+    beginTransaction(diffs: Diff[], { enableResourceValidation, filterResourceDiffsByResourceId, generateTerraform, skipActualResourceUpdate, yieldModelDiffs, yieldModelTransaction, yieldResourceDiffs, yieldResourceTransaction, }?: TransactionOptions): AsyncGenerator<DiffMetadata[][], DiffMetadata[][]>;
+    /**
+     * The diffs {@link TransactionService.applyExternalResourceDeletes} runs: the deletion of every
+     * external resource in `resourceDiffs`. A caller that has to decide whether to run them at all
+     * names them through this rather than repeating the filter.
+     *
+     * @internal
+     */
+    getExternalResourceDeletes(resourceDiffs: DiffMetadata[][]): DiffMetadata[];
+    /**
+     * @internal
+     */
+    registerModelActions(forModel: Constructable<UnknownModel>, actions: IUnknownModelAction[]): void;
+    /**
+     * @internal
+     */
+    registerOverlayActions(forOverlay: Constructable<UnknownOverlay>, actions: IUnknownModelAction[]): void;
+    /**
+     * @internal
+     */
+    registerResourceActions(forResource: Constructable<UnknownResource>, actions: IUnknownResourceAction[]): void;
+    /**
+     * @internal
+     */
+    unregisterModelActions(forModel: Constructable<UnknownModel>): void;
+    /**
+     * @internal
+     */
     private applyModels;
-    private applyResourcesDryRun;
+    /**
+     * @internal
+     */
     private applyResources;
+    /**
+     * Refuses two names the `uniqueProperties` of one resource class say must differ: two values of its path,
+     * from two resources or from one, sharing the values of its domain.
+     */
+    private ensureUniqueNames;
+    /**
+     * Contributes every resource in the new (desired) resource graph to the shared
+     * {@link TerraformService}: terraform resources via `toHCL()`, external resources via
+     * `addOctoTerraformExternalResource()`. Always processes the full desired state — terraform
+     * computes the actual create/update/delete against its own state.
+     *
+     * Order does not matter: terraform resources reference each other through deferred refs, and
+     * external resources defer their parent-input wiring — both are resolved later, once every
+     * resource is registered (see {@link TerraformService}'s wiring phase).
+     */
+    private generateTerraform;
+    /**
+     * @internal
+     */
     private getDiffsOfSameNode;
+    /**
+     * @internal
+     */
     private getDuplicateDiffs;
+    /**
+     * @internal
+     */
     private getMatchingDiffs;
+    /**
+     * The scope of the resources a node's actions create: the models the node sits under. An overlay
+     * sits where the nodes its own module created sit; the nodes it borrows from other modules are what
+     * it joins, so joining one more never moves what it created. An overlay joining only borrowed nodes
+     * sits where all of them sit. A model another member sits under is left out, since that member's
+     * context already names it.
+     */
+    private getResourceScope;
+    /**
+     * The names a resource holds that the `uniqueProperties` of its class say the provider keeps unique,
+     * each keyed by its class, path and domain. A path with no value holds no name.
+     */
+    private getUniqueNames;
+    /**
+     * Hands each committed resource's terraform state to the resource taking it over, so the two are one
+     * piece of infrastructure, updated or replaced in place: a resource now rendered into another module's
+     * folder, and an added resource taking a name of a deleted resource of its class. Without it terraform
+     * creates the new one while the old one is destroyed, and the provider refuses a name still held.
+     * A renamed external resource is left out: octo runs its actions itself, and a move would skip them.
+     */
+    private moveResources;
     /**
      * Before assigning order to a diff, all its node's parent diffs must be processed.
      * E.g. diff to add environment, depends on region to exist, thus add region diff gets processed first.
      */
     private setApplyOrder;
-    beginTransaction(diffs: Diff[], { enableResourceCapture, enableResourceValidation, yieldModelDiffs, yieldModelTransaction, yieldResourceDiffs, yieldResourceTransaction, }?: TransactionOptions): AsyncGenerator<DiffMetadata[][], DiffMetadata[][]>;
-    registerModelActions(forModel: Constructable<UnknownModel>, actions: IUnknownModelAction[]): void;
-    registerOverlayActions(forOverlay: Constructable<UnknownOverlay>, actions: IUnknownModelAction[]): void;
-    registerResourceActions(forResource: Constructable<UnknownResource>, actions: IUnknownResourceAction[]): void;
-    unregisterModelActions(forModel: Constructable<UnknownModel>): void;
-    unregisterOverlayActions(forOverlay: Constructable<UnknownOverlay>): void;
 }
 /**
  * @internal
  */
 export declare class TransactionServiceFactory {
     private static instance;
+    /**
+     * @internal
+     */
     static create(): Promise<TransactionService>;
 }