puls-dev 0.3.4 → 0.3.6

package/dist/core/resource.d.ts

@@ -1,12 +1,16 @@
+import type { FieldDiff } from "../types/diff.js";
 export declare abstract class BaseBuilder {
     name: string;
     protected isProtected: boolean;
     protected localDryRun: boolean | null;
     protected discoveryPromise: Promise<any>;
     protected sidecars: BaseBuilder[];
+    protected _adoptedId: string | null;
     /** @internal */
     _deployPromise: Promise<any>;
     /** @internal */
+    _resolveDiscovery(): Promise<any>;
+    /** @internal */
     _destroyPromise?: Promise<any>;
     /** @internal */
     _dependencies: BaseBuilder[];
@@ -17,6 +21,37 @@ export declare abstract class BaseBuilder {
     constructor(name: string);
     dependsOn(resource: BaseBuilder): this;
     protect(): this;
+    /**
+     * Adopt an existing cloud resource by its provider ID, bringing it under
+     * Puls management without recreating it. If name-based discovery finds the
+     * resource, that result wins; adoptId only kicks in when discovery returns
+     * null (i.e. the resource was created outside this stack or with a different
+     * naming convention).
+     *
+     * Outputs that depend on live API response fields (e.g. `out.host`) won't be
+     * resolved automatically — chain `.adoptOutput(key, value)` for each one you
+     * need for cross-stack wiring.
+     */
+    adoptId(id: string): this;
+    /**
+     * Pre-resolve a named output on this builder. Use alongside `adoptId` to
+     * supply known connection details (host, port, uri, etc.) so downstream
+     * resources can reference them before this builder deploys.
+     *
+     * @example
+     *   db = DO.Database("prod-db")
+     *     .adoptId("abc123")
+     *     .adoptOutput("host", "db.internal.example.com")
+     *     .adoptOutput("uri", "postgres://...");
+     */
+    /**
+     * Returns field-level differences between declared intent and live cloud state.
+     * Called by `Stack.diff()` for each resource that exists. Override in provider
+     * builders to surface meaningful drift fields. The default returns an empty array
+     * (no field-level diff available).
+     */
+    getDiff(_existing: any): FieldDiff[];
+    adoptOutput(key: string, value: any): this;
     dryRun(enabled?: boolean): this;
     beforeDeploy(callback: () => Promise<void> | void): this;
     afterDeploy(callback: (result: any) => Promise<void> | void): this;

package/dist/core/resource.js

@@ -5,9 +5,14 @@ export class BaseBuilder {
     localDryRun = null;
     discoveryPromise;
     sidecars = [];
+    _adoptedId = null;
     /** @internal */
     _deployPromise;
     /** @internal */
+    async _resolveDiscovery() {
+        return this.discoveryPromise;
+    }
+    /** @internal */
     _destroyPromise;
     /** @internal */
     _dependencies = [];
@@ -26,6 +31,56 @@ export class BaseBuilder {
         this.isProtected = true;
         return this;
     }
+    /**
+     * Adopt an existing cloud resource by its provider ID, bringing it under
+     * Puls management without recreating it. If name-based discovery finds the
+     * resource, that result wins; adoptId only kicks in when discovery returns
+     * null (i.e. the resource was created outside this stack or with a different
+     * naming convention).
+     *
+     * Outputs that depend on live API response fields (e.g. `out.host`) won't be
+     * resolved automatically — chain `.adoptOutput(key, value)` for each one you
+     * need for cross-stack wiring.
+     */
+    adoptId(id) {
+        this._adoptedId = id;
+        const original = this.discoveryPromise;
+        this.discoveryPromise = original.then((found) => {
+            if (!found) {
+                this.out?.id?.resolve?.(id);
+                return { id, status: "adopted", _adopted: true };
+            }
+            return found;
+        });
+        return this;
+    }
+    /**
+     * Pre-resolve a named output on this builder. Use alongside `adoptId` to
+     * supply known connection details (host, port, uri, etc.) so downstream
+     * resources can reference them before this builder deploys.
+     *
+     * @example
+     *   db = DO.Database("prod-db")
+     *     .adoptId("abc123")
+     *     .adoptOutput("host", "db.internal.example.com")
+     *     .adoptOutput("uri", "postgres://...");
+     */
+    /**
+     * Returns field-level differences between declared intent and live cloud state.
+     * Called by `Stack.diff()` for each resource that exists. Override in provider
+     * builders to surface meaningful drift fields. The default returns an empty array
+     * (no field-level diff available).
+     */
+    getDiff(_existing) {
+        return [];
+    }
+    adoptOutput(key, value) {
+        const out = this.out;
+        if (typeof out?.[key]?.resolve === "function") {
+            out[key].resolve(value);
+        }
+        return this;
+    }
     dryRun(enabled = true) {
         this.localDryRun = enabled;
         return this;
@@ -123,7 +178,8 @@ export class BaseBuilder {
     }
     async destroy() {
         const dryRun = this.isDryRunActive();
-        console.log(`\n🗑️  Destroying "${this.name}"...`);
+        const adoptedSuffix = this._adoptedId ? ` [adopted id=${this._adoptedId}]` : "";
+        console.log(`\n🗑️  Destroying "${this.name}"${adoptedSuffix}...`);
         console.log(`   ✅ [${dryRun ? "PLAN" : "OK"}] Resource "${this.name}" marked for destruction.`);
         await this.destroySidecars();
         return { destroyed: this.name };

package/dist/core/stack.d.ts

@@ -1,4 +1,5 @@
 import "reflect-metadata";
+import type { StackDiff } from "../types/diff.js";
 export declare abstract class Stack {
     /** @internal - called by @Deploy to register the instance for cross-stack references. */
     static _register(cls: Function, instance: Stack, region?: string): void;
@@ -16,6 +17,16 @@ export declare abstract class Stack {
      * }
      */
     static from<T extends Stack>(cls: new (...args: any[]) => T, region?: string): T;
+    /**
+     * Compares every declared resource against its live cloud state without
+     * making any API writes. Returns a structured `StackDiff` and prints a
+     * formatted report to the console.
+     *
+     * Field-level drift is surfaced for providers that implement `getDiff()`.
+     * Resources with no `getDiff()` override show only existence status
+     * (missing / in-sync / adopted).
+     */
+    diff(): Promise<StackDiff>;
     deploy(): Promise<Record<string, any>>;
     destroy(): Promise<Record<string, any>>;
 }

package/dist/core/stack.js

@@ -107,6 +107,45 @@ function printOutputs(stackName, outputs) {
     }
     console.log(`  └${line}┘`);
 }
+function printDiff(diff) {
+    console.log(`\n🔍 Diff: ${diff.stackName}`);
+    const propWidth = Math.max(...diff.resources.map((r) => r.prop.length), 4);
+    const nameWidth = Math.max(...diff.resources.map((r) => r.resource.length), 8);
+    for (const r of diff.resources) {
+        const prop = r.prop.padEnd(propWidth);
+        const name = r.resource.padEnd(nameWidth);
+        if (r.status === "in-sync") {
+            console.log(`   ${prop}  ${name}  ✅ in-sync`);
+        }
+        else if (r.status === "adopted") {
+            console.log(`   ${prop}  ${name}  🔗 adopted`);
+        }
+        else if (r.status === "missing") {
+            console.log(`   ${prop}  ${name}  ❌ missing  (will create)`);
+        }
+        else {
+            console.log(`   ${prop}  ${name}  ⚠️  drift`);
+            const fieldWidth = Math.max(...r.changes.map((c) => String(c.field).length), 8);
+            for (const c of r.changes) {
+                const field = String(c.field).padEnd(fieldWidth);
+                console.log(`      └─ ${field}  ${String(c.declared)}  →  ${c.live}`);
+            }
+        }
+    }
+    const driftCount = diff.resources.filter((r) => r.status === "drift").length;
+    const missingCount = diff.resources.filter((r) => r.status === "missing").length;
+    if (driftCount === 0 && missingCount === 0) {
+        console.log(`\n   ✅ All ${diff.resources.length} resources are in sync.`);
+    }
+    else {
+        const parts = [];
+        if (driftCount > 0)
+            parts.push(`${driftCount} drifted`);
+        if (missingCount > 0)
+            parts.push(`${missingCount} missing`);
+        console.log(`\n   ⚠️  ${parts.join(", ")} out of ${diff.resources.length} resources.`);
+    }
+}
 export class Stack {
     /** @internal - called by @Deploy to register the instance for cross-stack references. */
     static _register(cls, instance, region) {
@@ -135,6 +174,54 @@ export class Stack {
             throw new Error(`Stack "${cls.name}" ${region ? `for region "${region}" ` : ""}is not registered. Make sure it is decorated with @Deploy and its module is imported before referencing it.`);
         return instance;
     }
+    /**
+     * Compares every declared resource against its live cloud state without
+     * making any API writes. Returns a structured `StackDiff` and prints a
+     * formatted report to the console.
+     *
+     * Field-level drift is surfaced for providers that implement `getDiff()`.
+     * Resources with no `getDiff()` override show only existence status
+     * (missing / in-sync / adopted).
+     */
+    async diff() {
+        const props = Object.getOwnPropertyNames(this);
+        const entries = [];
+        for (const prop of props) {
+            const val = this[prop];
+            if (val instanceof BaseBuilder) {
+                entries.push({ prop, resource: val });
+            }
+            else if (Array.isArray(val)) {
+                for (const item of val) {
+                    if (item instanceof BaseBuilder) {
+                        entries.push({ prop, resource: item });
+                    }
+                }
+            }
+        }
+        const resources = [];
+        for (const { prop, resource } of entries) {
+            const existing = await resource._resolveDiscovery();
+            let status;
+            let changes = resource.getDiff(existing ?? {});
+            if (!existing) {
+                status = "missing";
+                changes = [];
+            }
+            else if (existing._adopted === true) {
+                status = "adopted";
+                changes = [];
+            }
+            else {
+                status = changes.length > 0 ? "drift" : "in-sync";
+            }
+            resources.push({ prop, resource: resource.name, status, changes });
+        }
+        const hasDrift = resources.some((r) => r.status === "drift" || r.status === "missing");
+        const result = { stackName: this.constructor.name, resources, hasDrift };
+        printDiff(result);
+        return result;
+    }
     async deploy() {
         const controller = new AbortController();
         const hosts = [];
@@ -193,7 +280,7 @@ export class Stack {
                         resource._deployPromise = (async () => {
                             try {
                                 // Yield so the map() loop finishes assigning all _deployPromise values before
-                                // any task checks its dependencies — a dependency that appears later in the list
+                                // any task checks its dependencies - a dependency that appears later in the list
                                 // would otherwise have an undefined _deployPromise and be silently skipped.
                                 await Promise.resolve();
                                 if (controller.signal.aborted) {

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from "./core/resource.js";
 export { Secret, clearResolvedSecrets } from "./core/secret.js";
 export { Output } from "./core/output.js";
 export * as INVENTORY_TYPES from "./types/inventory.js";
+export type { FieldDiff, ResourceDiff, StackDiff, ResourceStatus } from "./types/diff.js";
 export { SLACK, DISCORD } from "./core/hooks.js";

package/dist/providers/aws/api.js

@@ -60,6 +60,9 @@ function createAwsOfflineMock(command) {
         get(target, prop) {
             if (prop === "then")
                 return undefined;
+            // Pagination tokens must be undefined so discovery loops exit cleanly
+            if (prop === "NextToken" || prop === "NextMarker" || prop === "Marker" || prop === "ContinuationToken")
+                return undefined;
             if (prop === "CertificateArn")
                 return "arn:aws:acm:us-east-1:123456789012:certificate/mock-cert-uuid";
             if (prop === "HostedZoneId")

package/dist/providers/aws/ec2.d.ts

@@ -29,6 +29,11 @@ export declare class EC2VMBuilder extends BaseBuilder {
     sshPrivateKey(path: string): this;
     provision(...playbookPaths: (string | string[])[]): this;
     forceConfigCheck(): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     protected checkPort(ip: string, port: number): Promise<boolean>;
     protected runProvisioner(ip: string, script: string): Promise<void>;
     private discoverVM;

package/dist/providers/aws/ec2.js

@@ -67,6 +67,13 @@ export class EC2VMBuilder extends BaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.InstanceType !== this._instanceType) {
+            diffs.push({ field: "instanceType", declared: this._instanceType, live: existing.InstanceType });
+        }
+        return diffs;
+    }
     async checkPort(ip, port) {
         return checkPort(ip, port);
     }

package/dist/providers/aws/lambda.d.ts

@@ -20,6 +20,11 @@ export declare class LambdaBuilder extends BaseBuilder {
     timeout(seconds: number): this;
     role(arnOrBuilder: string | IAMRoleBuilder): this;
     env(vars: Record<string, string | SecretsBuilder>): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     private ensureRole;
     private buildZip;
     deploy(): Promise<{

package/dist/providers/aws/lambda.js

@@ -78,6 +78,30 @@ export class LambdaBuilder extends BaseBuilder {
         this._env = { ...this._env, ...vars };
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.Runtime !== this._runtime) {
+            diffs.push({ field: "runtime", declared: this._runtime, live: existing.Runtime });
+        }
+        if (existing.Handler !== this._handler) {
+            diffs.push({ field: "handler", declared: this._handler, live: existing.Handler });
+        }
+        if (existing.MemorySize !== this._memory) {
+            diffs.push({ field: "memory", declared: `${this._memory} MB`, live: `${existing.MemorySize} MB` });
+        }
+        if (existing.Timeout !== this._timeout) {
+            diffs.push({ field: "timeout", declared: `${this._timeout}s`, live: `${existing.Timeout}s` });
+        }
+        const liveEnv = existing.Environment?.Variables ?? {};
+        const declaredKeys = Object.keys(this._env);
+        const liveKeys = Object.keys(liveEnv);
+        const allKeys = new Set([...declaredKeys, ...liveKeys]);
+        const envDrift = [...allKeys].filter((k) => String(this._env[k]) !== String(liveEnv[k]));
+        if (envDrift.length > 0) {
+            diffs.push({ field: "env", declared: `${declaredKeys.length} vars`, live: `${liveKeys.length} vars (${envDrift.length} changed)` });
+        }
+        return diffs;
+    }
     async ensureRole() {
         if (this._roleBuilder) {
             return await this._roleBuilder.out.arn.get();

package/dist/providers/aws/list.js

@@ -3,16 +3,18 @@ import { ListBucketsCommand } from '@aws-sdk/client-s3';
 import { ListFunctionsCommand } from '@aws-sdk/client-lambda';
 import { DescribeDBInstancesCommand } from '@aws-sdk/client-rds';
 import { ListHostedZonesCommand } from '@aws-sdk/client-route-53';
-import { getCFClient, getS3Client, getLambdaClient, getRDSClient, getR53Client } from './api.js';
+import { DescribeInstancesCommand } from '@aws-sdk/client-ec2';
+import { getCFClient, getS3Client, getLambdaClient, getRDSClient, getR53Client, getEC2Client } from './api.js';
 import { Config } from '../../core/config.js';
 export async function listAwsResources() {
     const region = Config.get().providers.aws.region;
-    const [cfResult, s3Result, lambdaResult, rdsResult, r53Result] = await Promise.all([
+    const [cfResult, s3Result, lambdaResult, rdsResult, r53Result, ec2Result] = await Promise.all([
         getCFClient().send(new ListDistributionsCommand({})),
         getS3Client().send(new ListBucketsCommand({})),
         getLambdaClient().send(new ListFunctionsCommand({ MaxItems: 50 })),
         getRDSClient().send(new DescribeDBInstancesCommand({})),
         getR53Client().send(new ListHostedZonesCommand({})),
+        getEC2Client().send(new DescribeInstancesCommand({ MaxResults: 200 })),
     ]);
     const distributions = (cfResult.DistributionList?.Items ?? []).map((d) => ({
         id: d.Id,
@@ -40,5 +42,15 @@ export async function listAwsResources() {
         id: z.Id.replace('/hostedzone/', ''),
         recordCount: z.ResourceRecordSetCount ?? 0,
     }));
-    return { region, distributions, buckets, lambdas, rdsInstances, hostedZones };
+    const ec2Instances = (ec2Result.Reservations ?? [])
+        .flatMap((r) => r.Instances ?? [])
+        .filter((i) => i.State?.Name !== 'terminated')
+        .map((i) => ({
+        id: i.InstanceId,
+        name: i.Tags?.find((t) => t.Key === 'Name')?.Value ?? i.InstanceId,
+        type: i.InstanceType ?? 'unknown',
+        state: i.State?.Name ?? 'unknown',
+        publicIp: i.PublicIpAddress,
+    }));
+    return { region, distributions, buckets, lambdas, rdsInstances, hostedZones, ec2Instances };
 }

package/dist/providers/aws/rds.d.ts

@@ -24,6 +24,15 @@ export declare class RDSBuilder extends BaseBuilder {
     subnets(ids: string[]): this;
     securityGroups(ids: string[]): this;
     publicAccess(enabled?: boolean): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: boolean;
+        live: any;
+    })[];
     database(name: string): this;
     credentials(username: string, password: string): this;
     private discoverInstance;

package/dist/providers/aws/rds.js

@@ -54,6 +54,25 @@ export class RDSBuilder extends BaseBuilder {
         this._publicAccess = enabled;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.Engine !== this._engine) {
+            diffs.push({ field: "engine", declared: this._engine, live: existing.Engine });
+        }
+        if (existing.EngineVersion !== this._engineVersion) {
+            diffs.push({ field: "engineVersion", declared: this._engineVersion, live: existing.EngineVersion });
+        }
+        if (existing.DBInstanceClass !== this._instanceClass) {
+            diffs.push({ field: "instanceClass", declared: this._instanceClass, live: existing.DBInstanceClass });
+        }
+        if (existing.AllocatedStorage !== this._storage) {
+            diffs.push({ field: "storage", declared: `${this._storage} GB`, live: `${existing.AllocatedStorage} GB` });
+        }
+        if (existing.PubliclyAccessible !== this._publicAccess) {
+            diffs.push({ field: "publicAccess", declared: this._publicAccess, live: existing.PubliclyAccessible });
+        }
+        return diffs;
+    }
     database(name) {
         this._dbName = name;
         return this;

package/dist/providers/do/database.d.ts

@@ -26,6 +26,15 @@ export declare class DatabaseBuilder extends BaseBuilder {
     allowIp(cidr: string): this;
     allowDroplet(dropletId: string): this;
     allowTag(tagName: string): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: number;
+        live: any;
+    })[];
     private discoverCluster;
     deploy(): Promise<{
         name: string;

package/dist/providers/do/database.js

@@ -58,6 +58,25 @@ export class DatabaseBuilder extends BaseBuilder {
         this._firewallRules.push({ type: "tag", value: tagName });
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.engine !== this._engine) {
+            diffs.push({ field: "engine", declared: this._engine, live: existing.engine });
+        }
+        if (existing.version !== this._version) {
+            diffs.push({ field: "version", declared: this._version, live: existing.version });
+        }
+        if (existing.size !== this._size) {
+            diffs.push({ field: "size", declared: this._size, live: existing.size });
+        }
+        if (existing.region !== this._region) {
+            diffs.push({ field: "region", declared: this._region, live: existing.region });
+        }
+        if (existing.num_nodes !== this._nodes) {
+            diffs.push({ field: "nodes", declared: this._nodes, live: existing.num_nodes });
+        }
+        return diffs;
+    }
     async discoverCluster(name) {
         try {
             const api = getDoApi();

package/dist/providers/do/domain.js

@@ -104,7 +104,7 @@ export class DomainBuilder extends BaseBuilder {
         if (existing) {
             try {
                 const res = await api.get(`/domains/${this.domainName}/records?per_page=200`);
-                existingRecords = res.domain_records;
+                existingRecords = res.domain_records ?? [];
             }
             catch {
                 existingRecords = [];

package/dist/providers/do/droplet.d.ts

@@ -30,6 +30,11 @@ export declare class DropletBuilder extends BaseBuilder {
     vpc(uuid: string | Output<string>): this;
     provision(...playbookPaths: (string | string[])[]): this;
     forceConfigCheck(): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: any;
+        live: any;
+    }[];
     protected checkPort(ip: string, port: number): Promise<boolean>;
     protected runProvisioner(ip: string, script: string): Promise<void>;
     private resolveOrRegisterSshKey;

package/dist/providers/do/droplet.js

@@ -101,6 +101,16 @@ export class DropletBuilder extends BaseBuilder {
         this._forceConfigCheck = true;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.size_slug !== this.config.size) {
+            diffs.push({ field: "size", declared: this.config.size, live: existing.size_slug });
+        }
+        if (existing.region?.slug !== this.config.region) {
+            diffs.push({ field: "region", declared: this.config.region, live: existing.region?.slug });
+        }
+        return diffs;
+    }
     async checkPort(ip, port) {
         return checkPort(ip, port);
     }

package/dist/providers/do/list.js

@@ -20,11 +20,14 @@ function priceForSlug(slug) {
 }
 export async function listDoResources() {
     const api = getDoApi();
-    const [dropletsData, firewallsData, lbData, domainsData] = await Promise.all([
+    const [dropletsData, firewallsData, lbData, domainsData, dbData, appsData, vpcsData] = await Promise.all([
         api.get('/droplets?per_page=200'),
         api.get('/firewalls?per_page=200'),
         api.get('/load_balancers?per_page=200'),
         api.get('/domains?per_page=200'),
+        api.get('/databases?per_page=200'),
+        api.get('/apps?per_page=200'),
+        api.get('/vpcs?per_page=200'),
     ]);
     const droplets = dropletsData.droplets.map((d) => {
         const pub = (d.networks?.v4 ?? []).find((n) => n.type === 'public');
@@ -54,6 +57,26 @@ export async function listDoResources() {
         name: d.name,
         ttl: d.ttl,
     }));
+    const databases = (dbData.databases ?? []).map((d) => ({
+        id: d.id,
+        name: d.name,
+        engine: `${d.engine} ${d.version ?? ''}`.trim(),
+        region: d.region ?? '',
+        status: d.status ?? '',
+        nodeCount: d.num_nodes ?? 1,
+    }));
+    const apps = (appsData.apps ?? []).map((a) => ({
+        id: a.id,
+        name: a.spec?.name ?? a.id,
+        liveUrl: a.live_url ?? '',
+        status: a.active_deployment?.phase ?? 'unknown',
+    }));
+    const vpcs = (vpcsData.vpcs ?? []).map((v) => ({
+        id: v.id,
+        name: v.name,
+        region: v.region ?? '',
+        ipRange: v.ip_range ?? '',
+    }));
     const totalMonthlyCost = droplets.reduce((sum, d) => sum + d.monthlyCost, 0);
-    return { droplets, firewalls, loadBalancers, domains, totalMonthlyCost };
+    return { droplets, firewalls, loadBalancers, domains, databases, apps, vpcs, totalMonthlyCost };
 }

package/dist/providers/do/load_balancer.d.ts

@@ -41,6 +41,11 @@ export declare class LoadBalancerBuilder extends BaseBuilder {
     stickySession(type: 'cookies' | 'none', cookieName?: string, cookieTtlSeconds?: number): this;
     private resolveDropletIds;
     private resolveCertificateId;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     deploy(): Promise<any>;
     destroy(): Promise<any>;
 }

package/dist/providers/do/load_balancer.js

@@ -96,6 +96,13 @@ export class LoadBalancerBuilder extends BaseBuilder {
         }
         return match.id;
     }
+    getDiff(existing) {
+        const diffs = [];
+        if (existing.region?.slug !== this._region) {
+            diffs.push({ field: "region", declared: this._region, live: existing.region?.slug });
+        }
+        return diffs;
+    }
     async deploy() {
         const dryRun = this.isDryRunActive();
         const existing = await this.discoveryPromise;

package/dist/providers/do/vpc.d.ts

@@ -12,6 +12,11 @@ export declare class VPCBuilder extends BaseBuilder {
     region(r: string): this;
     ipRange(cidr: string): this;
     description(text: string): this;
+    getDiff(existing: any): {
+        field: string;
+        declared: string;
+        live: any;
+    }[];
     private discoverVpc;
     deploy(): Promise<{
         name: string;

package/dist/providers/do/vpc.js

@@ -26,6 +26,14 @@ export class VPCBuilder extends BaseBuilder {
         this._description = text;
         return this;
     }
+    getDiff(existing) {
+        const diffs = [];
+        // region and ip_range are immutable after creation
+        if (this._description !== undefined && existing.description !== this._description) {
+            diffs.push({ field: "description", declared: this._description, live: existing.description });
+        }
+        return diffs;
+    }
     async discoverVpc(name) {
         try {
             const api = getDoApi();

package/dist/providers/firebase/functions.d.ts

@@ -29,6 +29,15 @@ export declare class FirebaseFunctionsBuilder extends BaseBuilder {
     maxInstances(n: number): this;
     minInstances(n: number): this;
     env(vars: Record<string, string>): this;
+    getDiff(existing: any): ({
+        field: string;
+        declared: string;
+        live: any;
+    } | {
+        field: string;
+        declared: number;
+        live: any;
+    })[];
     private fnPath;
     private getExisting;
     private zipSource;