storybooker 0.19.3 → 0.22.0-canary.0

package/src/adapters/aws-s3.ts

@@ -0,0 +1,160 @@
+import {
+  type S3Client,
+  CreateBucketCommand,
+  DeleteBucketCommand,
+  ListBucketsCommand,
+  ListObjectsV2Command,
+  DeleteObjectsCommand,
+  PutObjectCommand,
+  HeadObjectCommand,
+  GetObjectCommand,
+} from "@aws-sdk/client-s3";
+import { Buffer } from "node:buffer";
+import { StorageAdapterErrors, type StorageAdapter } from "./_internal/storage.ts";
+
+export class AwsS3StorageService implements StorageAdapter {
+  #client: S3Client;
+
+  constructor(client: S3Client) {
+    this.#client = client;
+  }
+
+  metadata: StorageAdapter["metadata"] = { name: "AWS S3" };
+
+  createContainer: StorageAdapter["createContainer"] = async (containerId, options) => {
+    try {
+      await this.#client.send(
+        new CreateBucketCommand({ Bucket: genBucketNameFromContainerId(containerId) }),
+        { abortSignal: options.abortSignal },
+      );
+    } catch (error) {
+      throw new StorageAdapterErrors.ContainerAlreadyExistsError(containerId, error);
+    }
+  };
+
+  deleteContainer: StorageAdapter["deleteContainer"] = async (containerId, options) => {
+    try {
+      await this.#client.send(
+        new DeleteBucketCommand({ Bucket: genBucketNameFromContainerId(containerId) }),
+        { abortSignal: options.abortSignal },
+      );
+    } catch (error) {
+      throw new StorageAdapterErrors.ContainerDoesNotExistError(containerId, error);
+    }
+  };
+
+  hasContainer: StorageAdapter["hasContainer"] = async (containerId, options) => {
+    const buckets = await this.#client.send(new ListBucketsCommand({}), {
+      abortSignal: options.abortSignal,
+    });
+    return Boolean(
+      buckets.Buckets?.some((bucket) => bucket.Name === genBucketNameFromContainerId(containerId)),
+    );
+  };
+
+  listContainers: StorageAdapter["listContainers"] = async (options) => {
+    const buckets = await this.#client.send(new ListBucketsCommand({}), {
+      abortSignal: options.abortSignal,
+    });
+    // oxlint-disable-next-line no-non-null-assertion
+    return buckets.Buckets?.map((bucket) => bucket.Name!) ?? [];
+  };
+
+  deleteFiles: StorageAdapter["deleteFiles"] = async (containerId, filePathsOrPrefix, options) => {
+    try {
+      const bucket = genBucketNameFromContainerId(containerId);
+      let objects: { Key: string }[] = [];
+      if (typeof filePathsOrPrefix === "string") {
+        const resp = await this.#client.send(
+          new ListObjectsV2Command({
+            Bucket: bucket,
+            Prefix: filePathsOrPrefix,
+          }),
+          { abortSignal: options.abortSignal },
+        );
+        // oxlint-disable-next-line no-non-null-assertion
+        objects = (resp.Contents ?? []).map((obj) => ({ Key: obj.Key! }));
+      } else {
+        objects = filePathsOrPrefix.map((path) => ({ Key: path }));
+      }
+      if (objects.length === 0) {
+        return;
+      }
+
+      await this.#client.send(
+        new DeleteObjectsCommand({
+          Bucket: bucket,
+          Delete: { Objects: objects },
+        }),
+        { abortSignal: options.abortSignal },
+      );
+    } catch (error) {
+      throw new StorageAdapterErrors.CustomError(
+        undefined,
+        `Failed to delete files in container ${containerId}.`,
+        error,
+      );
+    }
+  };
+
+  uploadFiles: StorageAdapter["uploadFiles"] = async (containerId, files, options) => {
+    const bucket = genBucketNameFromContainerId(containerId);
+
+    const promises = files.map(async ({ content, path, mimeType }) => {
+      await this.#client
+        .send(
+          new PutObjectCommand({
+            Body: typeof content === "string" ? Buffer.from(content) : content,
+            Bucket: bucket,
+            ContentType: mimeType,
+            Key: path,
+          }),
+          { abortSignal: options.abortSignal },
+        )
+        .then((error: unknown) => {
+          options.logger.error(`Failed to upload file ${path} to bucket ${bucket}:`, error);
+        });
+    });
+
+    await Promise.allSettled(promises);
+  };
+
+  hasFile: StorageAdapter["hasFile"] = async (containerId, filepath, options) => {
+    try {
+      await this.#client.send(
+        new HeadObjectCommand({
+          Bucket: genBucketNameFromContainerId(containerId),
+          Key: filepath,
+        }),
+        { abortSignal: options.abortSignal },
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  downloadFile: StorageAdapter["downloadFile"] = async (containerId, filepath, options) => {
+    const bucket = genBucketNameFromContainerId(containerId);
+    const resp = await this.#client.send(new GetObjectCommand({ Bucket: bucket, Key: filepath }), {
+      abortSignal: options.abortSignal,
+    });
+
+    if (!resp.Body) {
+      throw new StorageAdapterErrors.FileDoesNotExistError(containerId, filepath);
+    }
+
+    return {
+      content: resp.Body as ReadableStream,
+      mimeType: resp.ContentType,
+      path: filepath,
+    };
+  };
+}
+
+function genBucketNameFromContainerId(containerId: string): string {
+  return containerId
+    .replaceAll(/[^\w-]+/g, "-")
+    .slice(0, 63)
+    .toLowerCase();
+}

package/src/adapters/azure-blob-storage.ts

@@ -0,0 +1,223 @@
+import type { BlobClient, BlobServiceClient, BlockBlobClient } from "@azure/storage-blob";
+import { Readable } from "node:stream";
+import type streamWeb from "node:stream/web";
+import { StorageAdapterErrors, type StorageAdapter } from "./_internal/storage.ts";
+
+export class AzureBlobStorageService implements StorageAdapter {
+  #client: BlobServiceClient;
+
+  constructor(client: BlobServiceClient) {
+    this.#client = client;
+  }
+
+  metadata: StorageAdapter["metadata"] = { name: "Azure Blob Storage" };
+
+  createContainer: StorageAdapter["createContainer"] = async (containerId, options) => {
+    try {
+      const containerName = genContainerNameFromContainerId(containerId);
+      await this.#client.createContainer(containerName, {
+        abortSignal: options.abortSignal,
+      });
+    } catch (error) {
+      throw new StorageAdapterErrors.ContainerAlreadyExistsError(containerId, error);
+    }
+  };
+
+  deleteContainer: StorageAdapter["deleteContainer"] = async (containerId, options) => {
+    try {
+      const containerName = genContainerNameFromContainerId(containerId);
+      await this.#client.getContainerClient(containerName).deleteIfExists({
+        abortSignal: options.abortSignal,
+      });
+    } catch (error) {
+      throw new StorageAdapterErrors.ContainerDoesNotExistError(containerId, error);
+    }
+  };
+
+  hasContainer: StorageAdapter["hasContainer"] = async (containerId, options) => {
+    const containerName = genContainerNameFromContainerId(containerId);
+    return await this.#client.getContainerClient(containerName).exists({
+      abortSignal: options.abortSignal,
+    });
+  };
+
+  listContainers: StorageAdapter["listContainers"] = async (options) => {
+    const containers: string[] = [];
+    for await (const item of this.#client.listContainers({
+      abortSignal: options.abortSignal,
+    })) {
+      containers.push(item.name);
+    }
+
+    return containers;
+  };
+
+  deleteFiles: StorageAdapter["deleteFiles"] = async (containerId, filePathsOrPrefix, options) => {
+    const containerName = genContainerNameFromContainerId(containerId);
+    const containerClient = this.#client.getContainerClient(containerName);
+    const blobClientsToDelete: BlobClient[] = [];
+
+    if (typeof filePathsOrPrefix === "string") {
+      for await (const blob of containerClient.listBlobsFlat({
+        abortSignal: options.abortSignal,
+        prefix: filePathsOrPrefix,
+      })) {
+        blobClientsToDelete.push(containerClient.getBlobClient(blob.name));
+      }
+    } else {
+      for (const filepath of filePathsOrPrefix) {
+        blobClientsToDelete.push(containerClient.getBlobClient(filepath));
+      }
+    }
+
+    if (blobClientsToDelete.length === 0) {
+      return;
+    }
+
+    const response = await containerClient.getBlobBatchClient().deleteBlobs(blobClientsToDelete, {
+      abortSignal: options.abortSignal,
+    });
+
+    if (response.errorCode) {
+      throw new StorageAdapterErrors.CustomError(
+        undefined,
+        `Failed to delete ${response.subResponsesFailedCount} blobs in container ${containerId}: ${response.errorCode}`,
+      );
+    }
+  };
+
+  uploadFiles: StorageAdapter["uploadFiles"] = async (containerId, files, options) => {
+    const containerName = genContainerNameFromContainerId(containerId);
+    const containerClient = this.#client.getContainerClient(containerName);
+
+    const { errors } = await promisePool(
+      files.map(({ content, path, mimeType }) => async (): Promise<void> => {
+        await uploadFileToBlobStorage(
+          containerClient.getBlockBlobClient(path),
+          content,
+          mimeType,
+          options.abortSignal,
+        );
+      }),
+      20,
+    );
+
+    if (errors.length > 0) {
+      options.logger.error(`Failed to upload ${errors.length} files. Errors:`, errors);
+    }
+  };
+
+  hasFile: StorageAdapter["hasFile"] = async (containerId, filepath, options) => {
+    const containerName = genContainerNameFromContainerId(containerId);
+    const containerClient = this.#client.getContainerClient(containerName);
+    const blockBlobClient = containerClient.getBlockBlobClient(filepath);
+    return await blockBlobClient.exists({ abortSignal: options.abortSignal });
+  };
+
+  downloadFile: StorageAdapter["downloadFile"] = async (containerId, filepath, options) => {
+    const containerName = genContainerNameFromContainerId(containerId);
+    const containerClient = this.#client.getContainerClient(containerName);
+    const blockBlobClient = containerClient.getBlockBlobClient(filepath);
+
+    if (!(await blockBlobClient.exists())) {
+      throw new StorageAdapterErrors.FileDoesNotExistError(containerId, filepath);
+    }
+
+    const downloadResponse = await blockBlobClient.download(0, undefined, {
+      abortSignal: options.abortSignal,
+    });
+
+    if (!downloadResponse.readableStreamBody) {
+      throw new StorageAdapterErrors.FileMalformedError(
+        containerId,
+        filepath,
+        "No readable stream body found.",
+      );
+    }
+
+    return {
+      content: downloadResponse.readableStreamBody as unknown as ReadableStream,
+      mimeType: downloadResponse.contentType,
+      path: filepath,
+    };
+  };
+}
+
+function genContainerNameFromContainerId(containerId: string): string {
+  return containerId
+    .replaceAll(/[^\w-]+/g, "-")
+    .slice(0, 255)
+    .toLowerCase();
+}
+
+// oxlint-disable-next-line max-params
+async function uploadFileToBlobStorage(
+  client: BlockBlobClient,
+  data: Blob | string | ReadableStream,
+  mimeType: string,
+  abortSignal?: AbortSignal,
+): Promise<void> {
+  if (typeof data === "string") {
+    const blob = new Blob([data], { type: mimeType });
+    await client.uploadData(blob, {
+      abortSignal,
+      blobHTTPHeaders: { blobContentType: mimeType },
+    });
+    return;
+  }
+
+  if (data instanceof Blob) {
+    await client.uploadData(data, {
+      abortSignal,
+      blobHTTPHeaders: { blobContentType: mimeType },
+    });
+    return;
+  }
+
+  if (data instanceof ReadableStream) {
+    const stream = data as unknown as streamWeb.ReadableStream;
+    await client.uploadStream(Readable.fromWeb(stream), undefined, undefined, {
+      abortSignal,
+      blobHTTPHeaders: { blobContentType: mimeType },
+    });
+    return;
+  }
+
+  throw new Error(`Unknown file type`);
+}
+
+async function promisePool<Result>(
+  tasks: (() => Promise<Result>)[],
+  concurrencyLimit: number,
+): Promise<{ errors: unknown[]; results: Result[] }> {
+  const promises: Promise<Result>[] = [];
+  const errors: unknown[] = [];
+  const executing = new Set();
+
+  for (const task of tasks) {
+    // Start the taskPromise
+    const promise = Promise.resolve().then(task);
+    promises.push(promise);
+
+    // Add to executing set
+    executing.add(promise);
+
+    // When the promise settles, remove it from executing
+    const cleanup = (): boolean => executing.delete(promise);
+    promise.then(cleanup).catch((error: unknown) => {
+      errors.push(error);
+      cleanup();
+    });
+
+    // If the number of running promises hit concurrencyLimit, wait for one to finish
+    if (executing.size >= concurrencyLimit) {
+      // oxlint-disable-next-line no-await-in-loop
+      await Promise.race(executing);
+    }
+  }
+
+  // Wait for all remaining tasks to finish
+  const results = await Promise.all(promises);
+
+  return { errors, results };
+}

package/src/adapters/azure-cosmos-db.ts

@@ -0,0 +1,158 @@
+import type { CosmosClient, Database } from "@azure/cosmos";
+import {
+  DatabaseAdapterErrors,
+  type DatabaseAdapter,
+  type DatabaseAdapterOptions,
+  type DatabaseDocumentListOptions,
+  type StoryBookerDatabaseDocument,
+} from "./_internal/database.ts";
+
+export class AzureCosmosDatabaseService implements DatabaseAdapter {
+  #db: Database;
+
+  constructor(client: CosmosClient, dbName = "StoryBooker") {
+    this.#db = client.database(dbName);
+  }
+
+  metadata: DatabaseAdapter["metadata"] = { name: "Azure Cosmos DB" };
+
+  init: DatabaseAdapter["init"] = async (options) => {
+    await this.#db.client.databases.createIfNotExists(
+      { id: this.#db.id },
+      { abortSignal: options.abortSignal },
+    );
+  };
+
+  listCollections: DatabaseAdapter["listCollections"] = async (options) => {
+    try {
+      const response = await this.#db.containers
+        .readAll({ abortSignal: options.abortSignal })
+        .fetchAll();
+      const collections: string[] = response.resources.map((resource) => resource.id);
+
+      return collections;
+    } catch (error) {
+      throw new DatabaseAdapterErrors.DatabaseNotInitializedError(error);
+    }
+  };
+
+  createCollection: DatabaseAdapter["createCollection"] = async (collectionId, options) => {
+    try {
+      await this.#db.containers.create({ id: collectionId }, { abortSignal: options.abortSignal });
+    } catch (error) {
+      throw new DatabaseAdapterErrors.CollectionAlreadyExistsError(collectionId, error);
+    }
+  };
+
+  hasCollection: DatabaseAdapter["hasCollection"] = async (collectionId, options) => {
+    try {
+      const response = await this.#db
+        .container(collectionId)
+        .read({ abortSignal: options.abortSignal });
+      return Boolean(response.resource);
+    } catch {
+      return false;
+    }
+  };
+
+  deleteCollection: DatabaseAdapter["deleteCollection"] = async (collectionId, options) => {
+    try {
+      await this.#db.container(collectionId).delete({ abortSignal: options.abortSignal });
+    } catch (error) {
+      throw new DatabaseAdapterErrors.CollectionDoesNotExistError(collectionId, error);
+    }
+  };
+
+  listDocuments: DatabaseAdapter["listDocuments"] = async <
+    Document extends StoryBookerDatabaseDocument,
+  >(
+    collectionId: string,
+    _listOptions: DatabaseDocumentListOptions<Document>,
+    options: DatabaseAdapterOptions,
+  ) => {
+    const items = await this.#db
+      .container(collectionId)
+      .items.readAll({ abortSignal: options.abortSignal })
+      .fetchAll();
+    return items.resources as Document[];
+  };
+
+  getDocument: DatabaseAdapter["getDocument"] = async <
+    Document extends StoryBookerDatabaseDocument,
+  >(
+    collectionId: string,
+    documentId: string,
+    options: DatabaseAdapterOptions,
+  ) => {
+    try {
+      const item = this.#db.container(collectionId).item(documentId);
+      const response = await item.read({ abortSignal: options.abortSignal });
+      const document: Document = response.resource;
+      document.id = documentId;
+      return document;
+    } catch (error) {
+      throw new DatabaseAdapterErrors.DocumentDoesNotExistError(collectionId, documentId, error);
+    }
+  };
+
+  createDocument: DatabaseAdapter["createDocument"] = async (
+    collectionId,
+    documentData,
+    options,
+  ) => {
+    try {
+      await this.#db
+        .container(collectionId)
+        .items.create(documentData, { abortSignal: options.abortSignal });
+    } catch (error) {
+      throw new DatabaseAdapterErrors.DocumentAlreadyExistsError(
+        collectionId,
+        documentData.id,
+        error,
+      );
+    }
+  };
+
+  hasDocument: DatabaseAdapter["hasDocument"] = async (collectionId, documentId, options) => {
+    const item = this.#db.container(collectionId).item(documentId);
+    const response = await item.read({ abortSignal: options.abortSignal });
+    return Boolean(response.resource);
+  };
+
+  deleteDocument: DatabaseAdapter["deleteDocument"] = async (collectionId, documentId, options) => {
+    try {
+      await this.#db
+        .container(collectionId)
+        .item(documentId)
+        .delete({ abortSignal: options.abortSignal });
+    } catch (error) {
+      throw new DatabaseAdapterErrors.DocumentDoesNotExistError(collectionId, documentId, error);
+    }
+  };
+
+  // oxlint-disable-next-line max-params
+  updateDocument: DatabaseAdapter["updateDocument"] = async (
+    collectionId,
+    documentId,
+    documentData,
+    options,
+  ) => {
+    try {
+      await this.#db
+        .container(collectionId)
+        .item(documentId)
+        .patch<Document>(
+          {
+            operations: Object.entries(documentData).map(([key, value]) => ({
+              op: "replace",
+              path: `/${key}`,
+              value,
+            })),
+          },
+          { abortSignal: options.abortSignal },
+        );
+    } catch (error) {
+      throw new DatabaseAdapterErrors.DocumentDoesNotExistError(collectionId, documentId, error);
+    }
+  };
+}