sitero-server 0.0.1

package/dist/src/application/resources/file/operations/commands/create-many/file-create-many-command.js

@@ -0,0 +1,74 @@
+import pLimit from 'p-limit';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { registerUploadedFile } from '../register-uploaded-file.js';
+import { createFileCreateManyInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+const MAX_CONCURRENCY = 5;
+function createFileCreateManyCommand(input) {
+  const {
+    authorization,
+    fileCommandPort,
+    fileLookupPort,
+    storageRemovePort,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileCreateManyInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2, context) => {
+      const limit = pLimit(MAX_CONCURRENCY);
+      const outcomes = await Promise.all(
+        input2.files.map(
+          (file) => limit(async () => {
+            try {
+              const created2 = await registerUploadedFile({
+                file,
+                context,
+                fileCommandPort,
+                fileLookupPort,
+                storageRemovePort,
+                observer
+              });
+              return { status: "created", file: created2 };
+            } catch (error) {
+              const failure = {
+                key: file.key,
+                code: "INTERNAL_ERROR"
+              };
+              await notifyObserverSafely(
+                observer,
+                (observer2) => observer2.onEffectError?.({
+                  context,
+                  effect: "persistence",
+                  error: { key: file.key, error }
+                })
+              );
+              return { status: "failed", failure };
+            }
+          })
+        )
+      );
+      const created = outcomes.flatMap(
+        (outcome) => outcome?.status === "created" ? [outcome.file] : []
+      );
+      const failed = outcomes.flatMap(
+        (outcome) => outcome?.status === "failed" ? [outcome.failure] : []
+      );
+      return operationResult.success({ created, failed });
+    }
+  );
+}
+
+export { createFileCreateManyCommand };

package/dist/src/application/resources/file/operations/commands/create-many/validation/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { fileCreateInputSchema } from '../../create/validation/schema.js';
+import { FILE_FIELD_ERROR_CODES } from '../../../../errors/codes.js';
+
+const fileCreateManyInputSchema = () => z.object({
+  files: z.array(fileCreateInputSchema()).min(1).superRefine((files, context) => {
+    const seenKeys = /* @__PURE__ */ new Set();
+    files.forEach((file, index) => {
+      if (seenKeys.has(file.key)) {
+        context.addIssue({
+          code: "custom",
+          message: FILE_FIELD_ERROR_CODES.KEY_DUPLICATE,
+          path: [index, "key"]
+        });
+        return;
+      }
+      seenKeys.add(file.key);
+    });
+  })
+});
+
+export { fileCreateManyInputSchema };

package/dist/src/application/resources/file/operations/commands/create-many/validation/validate-input.js

@@ -0,0 +1,7 @@
+import { fileCreateManyInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  return fileCreateManyInputSchema().parseAsync(input);
+}
+
+export { validateInput };

package/dist/src/application/resources/file/operations/commands/delete/cache.js

@@ -0,0 +1,11 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileDeleteInvalidationTags = (_, result) => {
+  const { file } = result.data;
+  return [
+    createResourceTag("file"),
+    createResourceTag("file", { id: file.id })
+  ].flat();
+};
+
+export { createFileDeleteInvalidationTags };

package/dist/src/application/resources/file/operations/commands/delete/file-delete-command.js

@@ -0,0 +1,27 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createFileDeleteInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createFileDeleteCommand(input) {
+  const { authorization, fileCommandPort, fileQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileDeleteInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput({ input: input2, fileQueryPort });
+      }
+    },
+    async (input2) => {
+      const file = await fileCommandPort.softDelete({ id: input2.id });
+      return operationResult.success({ file });
+    }
+  );
+}
+
+export { createFileDeleteCommand };

package/dist/src/application/resources/file/operations/commands/delete/validation/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileDeleteInputSchema = () => z.object({
+  id: idSchema()
+});
+
+export { fileDeleteInputSchema };

package/dist/src/application/resources/file/operations/commands/delete/validation/validate-input.js

@@ -0,0 +1,23 @@
+import { FileNotFoundError, FileDeleteAlreadyDeletedError, FileDeleteLockedError, FileDeleteInUseError } from '../../../../errors/operation-errors.js';
+import { fileDeleteInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, fileQueryPort } = input;
+  const validatedInput = await fileDeleteInputSchema().parseAsync(rawInput);
+  const file = await fileQueryPort.findDetail({ id: validatedInput.id });
+  if (!file) {
+    throw new FileNotFoundError();
+  }
+  if (file.deletedAt) {
+    throw new FileDeleteAlreadyDeletedError();
+  }
+  if (file.isLocked) {
+    throw new FileDeleteLockedError();
+  }
+  if (file.isInUse) {
+    throw new FileDeleteInUseError();
+  }
+  return validatedInput;
+}
+
+export { validateInput };

package/dist/src/application/resources/file/operations/commands/delete-many/cache.js

@@ -0,0 +1,12 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileDeleteManyInvalidationTags = (_, result) => {
+  const { deleted } = result.data;
+  if (deleted.length === 0) return [];
+  return [
+    createResourceTag("file"),
+    ...deleted.map((file) => createResourceTag("file", { id: file.id }))
+  ].flat();
+};
+
+export { createFileDeleteManyInvalidationTags };

package/dist/src/application/resources/file/operations/commands/delete-many/file-delete-many-command.js

@@ -0,0 +1,94 @@
+import pLimit from 'p-limit';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { FILE_ERROR_CODES } from '../../../errors/codes.js';
+import { createFileDeleteManyInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+const MAX_CONCURRENCY = 5;
+function createFileDeleteManyCommand(input) {
+  const { authorization, fileCommandPort, fileQueryPort, observer } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileDeleteManyInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2, context) => {
+      const limit = pLimit(MAX_CONCURRENCY);
+      const outcomes = await Promise.all(
+        input2.ids.map(
+          (id) => limit(async () => {
+            try {
+              const file = await fileQueryPort.findDetail({ id });
+              if (!file) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.NOT_FOUND
+                };
+              }
+              if (file.deletedAt) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.DELETE_ALREADY_DELETED
+                };
+              }
+              if (file.isLocked) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.DELETE_LOCKED
+                };
+              }
+              if (file.isInUse) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.DELETE_IN_USE
+                };
+              }
+              const deleted = await fileCommandPort.softDelete({ id });
+              return { status: "deleted", file: deleted };
+            } catch (error) {
+              const failure = {
+                id,
+                code: "INTERNAL_ERROR"
+              };
+              await notifyObserverSafely(
+                observer,
+                (observer2) => observer2.onEffectError?.({
+                  context,
+                  effect: "persistence",
+                  error: { id, error }
+                })
+              );
+              return { status: "failed", failure };
+            }
+          })
+        )
+      );
+      return operationResult.success({
+        deleted: outcomes.flatMap(
+          (outcome) => outcome.status === "deleted" ? [outcome.file] : []
+        ),
+        skipped: outcomes.flatMap(
+          (outcome) => outcome.status === "skipped" ? [{ id: outcome.id, code: outcome.code }] : []
+        ),
+        failed: outcomes.flatMap(
+          (outcome) => outcome.status === "failed" ? [outcome.failure] : []
+        )
+      });
+    }
+  );
+}
+
+export { createFileDeleteManyCommand };

package/dist/src/application/resources/file/operations/commands/delete-many/validation/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileDeleteManyInputSchema = () => z.object({
+  ids: z.array(idSchema()).min(1)
+});
+
+export { fileDeleteManyInputSchema };

package/dist/src/application/resources/file/operations/commands/delete-many/validation/validate-input.js

@@ -0,0 +1,8 @@
+import { fileDeleteManyInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { ids } = await fileDeleteManyInputSchema().parseAsync(input);
+  return { ids: [...new Set(ids)] };
+}
+
+export { validateInput };

package/dist/src/application/resources/file/operations/commands/purge-many/cache.js

@@ -0,0 +1,12 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFilePurgeManyInvalidationTags = (_, result) => {
+  const { purged } = result.data;
+  if (purged.length === 0) return [];
+  return [
+    createResourceTag("file"),
+    ...purged.map((file) => createResourceTag("file", { id: file.id }))
+  ].flat();
+};
+
+export { createFilePurgeManyInvalidationTags };

package/dist/src/application/resources/file/operations/commands/purge-many/file-purge-many-command.js

@@ -0,0 +1,129 @@
+import { FILE_ERROR_CODES } from '../../../errors/codes.js';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import pLimit from 'p-limit';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { createFilePurgeManyInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+const MAX_CONCURRENCY = 5;
+function createFilePurgeManyCommand(input) {
+  const {
+    authorization,
+    fileCommandPort,
+    fileQueryPort,
+    storageRemovePort,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFilePurgeManyInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2, context) => {
+      const limit = pLimit(MAX_CONCURRENCY);
+      const outcomes = await Promise.all(
+        input2.ids.map(
+          (id) => limit(async () => {
+            try {
+              const file = await fileQueryPort.findDetail({ id });
+              if (!file) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.NOT_FOUND
+                };
+              }
+              if (!file.deletedAt) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.PURGE_NOT_DELETED
+                };
+              }
+              if (file.isLocked) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.PURGE_LOCKED
+                };
+              }
+              if (file.isInUse) {
+                return {
+                  status: "skipped",
+                  id,
+                  code: FILE_ERROR_CODES.PURGE_IN_USE
+                };
+              }
+              let purged;
+              try {
+                purged = await fileCommandPort.purge({ id });
+              } catch (error) {
+                const failure = {
+                  id,
+                  code: "INTERNAL_ERROR"
+                };
+                await notifyObserverSafely(
+                  observer,
+                  (observer2) => observer2.onEffectError?.({
+                    context,
+                    effect: "persistence",
+                    error: { id, error }
+                  })
+                );
+                return { status: "failed", failure };
+              }
+              try {
+                await storageRemovePort.remove({ key: file.key });
+              } catch (error) {
+                await notifyObserverSafely(
+                  observer,
+                  (observer2) => observer2.onEffectError?.({
+                    context,
+                    effect: "storage",
+                    error: { id, key: file.key, error }
+                  })
+                );
+              }
+              return { status: "purged", file: purged };
+            } catch (error) {
+              const failure = {
+                id,
+                code: "INTERNAL_ERROR"
+              };
+              await notifyObserverSafely(
+                observer,
+                (observer2) => observer2.onEffectError?.({
+                  context,
+                  effect: "persistence",
+                  error: { id, error }
+                })
+              );
+              return { status: "failed", failure };
+            }
+          })
+        )
+      );
+      return operationResult.success({
+        purged: outcomes.flatMap(
+          (outcome) => outcome.status === "purged" ? [outcome.file] : []
+        ),
+        skipped: outcomes.flatMap(
+          (outcome) => outcome.status === "skipped" ? [{ id: outcome.id, code: outcome.code }] : []
+        ),
+        failed: outcomes.flatMap(
+          (outcome) => outcome.status === "failed" ? [outcome.failure] : []
+        )
+      });
+    }
+  );
+}
+
+export { createFilePurgeManyCommand };

package/dist/src/application/resources/file/operations/commands/purge-many/validation/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const filePurgeManyInputSchema = () => z.object({
+  ids: z.array(idSchema()).min(1)
+});
+
+export { filePurgeManyInputSchema };

package/dist/src/application/resources/file/operations/commands/purge-many/validation/validate-input.js

@@ -0,0 +1,10 @@
+import { filePurgeManyInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const validatedInput = await filePurgeManyInputSchema().parseAsync(input);
+  return {
+    ids: [...new Set(validatedInput.ids)]
+  };
+}
+
+export { validateInput };

package/dist/src/application/resources/file/operations/commands/register-uploaded-file.js

@@ -0,0 +1,34 @@
+import { removeUnregisteredUpload } from './remove-unregistered-upload.js';
+
+async function registerUploadedFile(input) {
+  const {
+    file: inputFile,
+    context,
+    fileCommandPort,
+    fileLookupPort,
+    storageRemovePort,
+    observer
+  } = input;
+  const writeInput = {
+    ...inputFile,
+    translations: inputFile.translations.map((translation) => ({
+      ...translation,
+      name: translation.name ?? inputFile.originalName
+    }))
+  };
+  try {
+    return await fileCommandPort.create(writeInput);
+  } catch (createError) {
+    await removeUnregisteredUpload({
+      key: inputFile.key,
+      context,
+      fileLookupPort,
+      storageRemovePort,
+      observer,
+      cause: createError
+    });
+    throw createError;
+  }
+}
+
+export { registerUploadedFile };

package/dist/src/application/resources/file/operations/commands/remove-unregistered-upload.js

@@ -0,0 +1,35 @@
+import 'zod';
+import { notifyObserverSafely } from '../../../../../kernel/observer/notify-observer-safely.js';
+
+async function removeUnregisteredUpload(input) {
+  const { key, context, fileLookupPort, storageRemovePort, observer, cause } = input;
+  let existing;
+  try {
+    existing = await fileLookupPort.find({ key });
+  } catch (confirmationError) {
+    await notifyObserverSafely(
+      observer,
+      (observer2) => observer2.onEffectError?.({
+        context,
+        effect: "storage",
+        error: { key, cause, confirmationError }
+      })
+    );
+    return;
+  }
+  if (existing) return;
+  try {
+    await storageRemovePort.remove({ key });
+  } catch (cleanupError) {
+    await notifyObserverSafely(
+      observer,
+      (observer2) => observer2.onEffectError?.({
+        context,
+        effect: "storage",
+        error: { key, cause, cleanupError }
+      })
+    );
+  }
+}
+
+export { removeUnregisteredUpload };

package/dist/src/application/resources/file/operations/commands/replace-content/cache.js

@@ -0,0 +1,8 @@
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createFileReplaceContentInvalidationTags = (_, result) => [
+  createResourceTag("file"),
+  createResourceTag("file", { id: result.data.file.id })
+].flat();
+
+export { createFileReplaceContentInvalidationTags };

package/dist/src/application/resources/file/operations/commands/replace-content/file-replace-content-command.js

@@ -0,0 +1,70 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { notifyObserverSafely } from '../../../../../../kernel/observer/notify-observer-safely.js';
+import { removeUnregisteredUpload } from '../remove-unregistered-upload.js';
+import { createFileReplaceContentInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createFileReplaceContentCommand(input) {
+  const {
+    authorization,
+    fileReplaceContentPort,
+    fileLookupPort,
+    fileQueryPort,
+    storageRemovePort,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileReplaceContentInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput({ input: input2, fileQueryPort });
+      }
+    },
+    async (input2, context) => {
+      const { previous, ...uploadedObject } = input2;
+      const writeInput = {
+        ...uploadedObject,
+        expectedKey: previous.key
+      };
+      try {
+        const file = await fileReplaceContentPort.replaceContent(writeInput);
+        try {
+          await storageRemovePort.remove({ key: previous.key });
+        } catch (error) {
+          await notifyObserverSafely(
+            observer,
+            (observer2) => observer2.onEffectError?.({
+              context,
+              effect: "storage",
+              error: {
+                id: previous.id,
+                oldKey: previous.key,
+                newKey: file.key,
+                error
+              }
+            })
+          );
+        }
+        return operationResult.success({ file });
+      } catch (replaceError) {
+        await removeUnregisteredUpload({
+          key: input2.key,
+          context,
+          fileLookupPort,
+          storageRemovePort,
+          observer,
+          cause: replaceError
+        });
+        throw replaceError;
+      }
+    }
+  );
+}
+
+export { createFileReplaceContentCommand };

package/dist/src/application/resources/file/operations/commands/replace-content/validation/schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { requiredTextSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileReplaceContentInputSchema = () => z.object({
+  id: idSchema(),
+  key: requiredTextSchema(),
+  originalName: requiredTextSchema(),
+  size: z.number().int().nonnegative(),
+  mimeType: requiredTextSchema(),
+  width: z.number().int().nonnegative().nullable(),
+  height: z.number().int().nonnegative().nullable(),
+  duration: z.number().nonnegative().nullable()
+});
+
+export { fileReplaceContentInputSchema };

package/dist/src/application/resources/file/operations/commands/replace-content/validation/validate-input.js

@@ -0,0 +1,26 @@
+import { FileNotFoundError, FileReplaceContentDeletedError, FileReplaceContentLockedError, FileReplaceContentInUseError, FileReplaceContentSameKeyError } from '../../../../errors/operation-errors.js';
+import { fileReplaceContentInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, fileQueryPort } = input;
+  const validatedInput = await fileReplaceContentInputSchema().parseAsync(rawInput);
+  const previous = await fileQueryPort.findDetail({ id: validatedInput.id });
+  if (!previous) {
+    throw new FileNotFoundError();
+  }
+  if (previous.deletedAt) {
+    throw new FileReplaceContentDeletedError();
+  }
+  if (previous.isLocked) {
+    throw new FileReplaceContentLockedError();
+  }
+  if (previous.isInUse) {
+    throw new FileReplaceContentInUseError();
+  }
+  if (previous.key === validatedInput.key) {
+    throw new FileReplaceContentSameKeyError();
+  }
+  return { ...validatedInput, previous };
+}
+
+export { validateInput };