import * as backupsearch from "@distilled.cloud/aws/backupsearch";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";
import { readBackupSearchTags, syncBackupSearchTags } from "./internal.ts";
export interface S3ExportSpecification {
/** Name of the destination S3 bucket that receives the results `.csv`. */
destinationBucket: string;
/** Key prefix under which the results are written. */
destinationPrefix?: string;
}
export interface ExportSpecification {
/** Export the search results to an S3 bucket. */
s3ExportSpecification: S3ExportSpecification;
}
export interface ExportJobProps {
/**
* Identifier of the search job whose results are exported. Immutable —
* changing it replaces the export job.
*/
searchJobIdentifier: string;
/**
* Where the results are exported to. Immutable — changing it replaces the
* export job.
*/
exportSpecification: ExportSpecification;
/**
* ARN of the IAM role BackupSearch assumes to write the export to the
* destination bucket. Immutable — changing it replaces the export job.
*/
roleArn?: string;
/**
* User-defined tags for the export job.
*/
tags?: Record<string, string>;
}
export interface ExportJob extends Resource<
"AWS.BackupSearch.ExportJob",
ExportJobProps,
{
/**
* Service-assigned unique ID of the export job.
*/
exportJobIdentifier: string;
/**
* ARN of the export job.
*/
exportJobArn: string;
/**
* ARN of the search job whose results are exported.
*/
searchJobArn: string | undefined;
/**
* Current status of the export job (e.g. `RUNNING`, `COMPLETED`).
*/
status: string;
},
never,
Providers
> {}
/**
* An AWS Backup Search export job — transmits the results of a completed
* search job to a designated S3 bucket as a `.csv` file, retaining them
* beyond the search job's seven-day retention. An export job is immutable
* once started and cannot be stopped or deleted; its record ages out
* server-side.
*
* ### Exporting Search Results
* **Example:** Export to an S3 Bucket
* ```typescript
* const exportJob = yield* BackupSearch.ExportJob("Results", {
* searchJobIdentifier: search.searchJobIdentifier,
* exportSpecification: {
* s3ExportSpecification: {
* destinationBucket: bucket.bucketName,
* destinationPrefix: "backup-search-results/",
* },
* },
* roleArn: role.roleArn,
* });
* ```
*
* @resource
*/
export const ExportJob = Resource<ExportJob>("AWS.BackupSearch.ExportJob");
export const ExportJobProvider = () =>
Provider.effect(
ExportJob,
Effect.gen(function* () {
const get = Effect.fn(function* (exportJobIdentifier: string) {
return yield* backupsearch
.getSearchResultExportJob({
ExportJobIdentifier: exportJobIdentifier,
})
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
});
const toAttrs = (
job: backupsearch.GetSearchResultExportJobOutput | backupsearch.ExportJobSummary,
) => ({
exportJobIdentifier: job.ExportJobIdentifier,
exportJobArn: job.ExportJobArn!,
searchJobArn: job.SearchJobArn,
status: (job.Status ?? "UNKNOWN") as string,
});
return {
stables: ["exportJobIdentifier", "exportJobArn"],
diff: Effect.fn(function* ({ olds, news }) {
if (!isResolved(news)) return undefined;
if (
(olds.searchJobIdentifier ?? undefined) !== (news.searchJobIdentifier ?? undefined) ||
(olds.roleArn ?? undefined) !== (news.roleArn ?? undefined) ||
JSON.stringify(olds.exportSpecification ?? null) !==
JSON.stringify(news.exportSpecification ?? null)
) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ id, output }) {
if (!output?.exportJobIdentifier) return undefined;
const job = yield* get(output.exportJobIdentifier);
if (job === undefined) return undefined;
const attrs = toAttrs(job);
const tags =
job.ExportJobArn !== undefined ? yield* readBackupSearchTags(job.ExportJobArn) : {};
return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
}),
reconcile: Effect.fn(function* ({ id, news, output, session }) {
const internalTags = yield* createInternalTags(id);
const desiredTags = { ...internalTags, ...news.tags };
// OBSERVE — output is only an identifier cache; the job may be gone.
let job =
output?.exportJobIdentifier !== undefined
? yield* get(output.exportJobIdentifier)
: undefined;
// ENSURE — an export job is immutable once started; start it if
// missing. Any change to its inputs is a replacement (diff).
if (job === undefined) {
const started = yield* backupsearch.startSearchResultExportJob({
SearchJobIdentifier: news.searchJobIdentifier,
ExportSpecification: {
s3ExportSpecification: {
DestinationBucket:
news.exportSpecification.s3ExportSpecification.destinationBucket,
DestinationPrefix:
news.exportSpecification.s3ExportSpecification.destinationPrefix,
},
},
RoleArn: news.roleArn,
Tags: desiredTags,
});
job = yield* backupsearch.getSearchResultExportJob({
ExportJobIdentifier: started.ExportJobIdentifier,
});
} else if (job.ExportJobArn !== undefined) {
// SYNC — tags are the only mutable aspect; diff against OBSERVED.
yield* syncBackupSearchTags(job.ExportJobArn, desiredTags);
}
yield* session.note(job.ExportJobIdentifier);
return toAttrs(job);
}),
// An export job cannot be stopped or deleted — its record ages out
// server-side and the exported .csv lives in the destination bucket.
delete: () => Effect.void,
list: () =>
backupsearch.listSearchResultExportJobs.pages({}).pipe(
Stream.runCollect,
Effect.map((chunk) =>
Array.from(chunk)
.flatMap((page) => page.ExportJobs ?? [])
.map(toAttrs),
),
),
};
}),
);