@stacksjs/ts-cloud 0.2.22 → 0.2.24

package/dist/object-storage/migrate.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Cross-provider object-storage migration.
+ *
+ * Copies objects from one S3-compatible bucket to another — AWS S3, Backblaze
+ * B2, Hetzner Object Storage, in any direction. Both sides are driven by the
+ * same {@link createObjectStorageClient}, so the only thing that changes per
+ * side is the provider/region/endpoint/credentials.
+ *
+ * Bytes are copied (not strings) via {@link S3Client.getObjectBytes}, so binary
+ * payloads (images, archives, mail attachments) survive intact. Content-Type is
+ * preserved when the source reports it.
+ *
+ * The copy is idempotent: an object already present at the destination with the
+ * same size is skipped unless `force` is set. Keys may be remapped by stripping
+ * `fromPrefix` and prepending `toPrefix`, and filtered with include/exclude
+ * prefix lists so an operator can clearly see what was migrated vs. deliberately
+ * left behind.
+ */
+import type { S3Client } from '../aws/s3';
+import type { ObjectStorageProvider } from './index';
+/** One side (source or destination) of a migration. */
+export interface MigrateEndpoint {
+    provider: ObjectStorageProvider;
+    bucket: string;
+    region?: string;
+    /** Endpoint host override (no scheme). Defaults to the provider's standard endpoint. */
+    endpoint?: string;
+    forcePathStyle?: boolean;
+    /** Key prefix. On the source it scopes/strips; on the dest it is prepended. */
+    prefix?: string;
+    /** Explicit credentials. When omitted, resolved from the provider's env vars. */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Pre-built client (used by tests to inject an in-memory mock). */
+    client?: S3Client;
+}
+export interface MigrateOptions {
+    from: MigrateEndpoint;
+    to: MigrateEndpoint;
+    /** Only copy keys whose (source) key starts with one of these prefixes. */
+    include?: string[];
+    /** Skip keys whose (source) key starts with one of these prefixes. */
+    exclude?: string[];
+    /** Plan only — do not write to the destination. */
+    dryRun?: boolean;
+    /** Re-copy even if the destination already has an object of the same size. */
+    force?: boolean;
+    /** Delete destination keys (within the dest prefix) that are not in the copied set. Default OFF. */
+    deleteExtraneous?: boolean;
+    /** Max in-flight copies. Default 8. */
+    concurrency?: number;
+    /** After copying, re-list the destination and assert counts + sizes match the copied set. */
+    verify?: boolean;
+    /** Optional progress callback, invoked per object after it is copied/skipped. */
+    onProgress?: (event: MigrateProgress) => void;
+}
+export interface MigrateProgress {
+    /** Source key. */
+    key: string;
+    /** Destination key the object maps to. */
+    destKey: string;
+    size: number;
+    action: 'copied' | 'skipped' | 'excluded' | 'error' | 'planned';
+    /** 1-based index of this object within the full source listing. */
+    index: number;
+    total: number;
+}
+export interface MigrateError {
+    key: string;
+    message: string;
+}
+export interface MigratePlanItem {
+    key: string;
+    destKey: string;
+    size: number;
+}
+export interface MigrateResult {
+    copied: number;
+    skipped: number;
+    excluded: number;
+    bytesCopied: number;
+    errors: MigrateError[];
+    /** Keys that were excluded by include/exclude filters (source keys). */
+    excludedKeys: string[];
+    /** Keys deleted from the destination via `deleteExtraneous`. */
+    deleted: string[];
+    /** When `dryRun` is set, the objects that would be copied. */
+    plan?: MigratePlanItem[];
+    /** Verification outcome when `verify` is set. */
+    verification?: MigrateVerification;
+}
+export interface MigrateVerification {
+    ok: boolean;
+    /** Number of (key,size) pairs that matched at the destination. */
+    matched: number;
+    /** Copied keys missing at the destination. */
+    missing: string[];
+    /** Copied keys present at the destination but with a different size. */
+    sizeMismatches: Array<{
+        key: string;
+        expected: number;
+        actual: number;
+    }>;
+}
+/**
+ * Compute the destination key for a source key: strip the source prefix, then
+ * prepend the destination prefix. Exported for unit testing.
+ */
+export declare function remapKey(sourceKey: string, fromPrefix?: string, toPrefix?: string): string;
+/**
+ * Decide whether a source key passes the include/exclude prefix filters.
+ * `include` (when non-empty) is a whitelist; `exclude` always wins. Exported for
+ * unit testing.
+ */
+export declare function keyMatchesFilters(key: string, include?: string[], exclude?: string[]): boolean;
+/**
+ * Migrate objects from one S3-compatible bucket to another.
+ *
+ * @returns a structured {@link MigrateResult} so callers (CLI, buddy, scripts)
+ * can report exactly what was copied, skipped, excluded, deleted and verified.
+ */
+export declare function migrateObjectStorage(options: MigrateOptions): Promise<MigrateResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/ts-cloud",
   "type": "module",
-  "version": "0.2.22",
+  "version": "0.2.24",
   "description": "A lightweight, performant infrastructure-as-code library and CLI for deploying both server-based (EC2) and serverless applications.",
   "author": "Chris Breuer <chris@stacksjs.com>",
   "license": "MIT",
@@ -89,8 +89,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.2.22",
-    "@ts-cloud/core": "0.2.22",
+    "@ts-cloud/aws-types": "0.2.24",
+    "@ts-cloud/core": "0.2.24",
     "@stacksjs/ts-xml": "^0.1.0"
   },
   "devDependencies": {

package/dist/drivers/shared/caddyfile.d.ts

@@ -1,46 +0,0 @@
-import type { CaddyAppConfig, CaddyProxyConfig, SiteConfig } from '@ts-cloud/core';
-/** A domain is "on-demand" (needs lazy TLS) if it's a wildcard or bare catch-all. */
-export declare function isOnDemandDomain(domain: string): boolean;
-/**
- * The on-server install path a static site's `root` is shipped to. Mirrors the
- * release layout used by the systemd app deploy (`/var/www/<name>`), so a box
- * can host both proxied apps and file-served static sites side by side.
- */
-export declare function staticSiteServerRoot(name: string): string;
-/**
- * Build a complete Caddyfile from a typed {@link CaddyProxyConfig}.
- *
- * Produces:
- *  - a global options block (ACME email, on-demand TLS `ask`, staging CA, extras);
- *  - one site block per unique domain set, each performing host-based routing to
- *    its upstream app(s);
- *  - `tls { on_demand }` inside any block whose domains are wildcards/catch-all.
- *
- * Returns `undefined` when there's nothing to route (no apps, no raw).
- */
-export declare function buildCaddyfileFromProxy(proxy: CaddyProxyConfig): string | undefined;
-/**
- * Derive a {@link CaddyProxyConfig} from the legacy `sites` map: every site
- * that declares a `domain` + `port` becomes a Caddy app. Keeps single-app /
- * sites-driven deploys working without an explicit `compute.proxy` block.
- */
-export declare function proxyConfigFromSites(sites: Record<string, SiteConfig>): CaddyProxyConfig & {
-    apps: CaddyAppConfig[];
-};
-/**
- * Resolve the final Caddyfile for a deploy. Prefers the typed `compute.proxy`
- * config (merging in `sites`-derived apps when `proxy.apps` is omitted), and
- * falls back to deriving everything from `sites`.
- *
- * Returns `undefined` when there's nothing to route.
- */
-export declare function resolveCaddyfile(sites: Record<string, SiteConfig>, proxy?: CaddyProxyConfig): string | undefined;
-/**
- * Build a Caddyfile from site configs. Sites sharing a domain are grouped;
- * explicit paths are ordered before catch-all routes.
- *
- * @deprecated Prefer {@link resolveCaddyfile} / {@link buildCaddyfileFromProxy},
- * which support multi-app host routing and on-demand TLS. Retained for
- * backward compatibility.
- */
-export declare function buildCaddyfile(sites: Record<string, SiteConfig>): string | undefined;