sitero-server 0.0.1

package/dist/src/application/resources/config/collect-config-file-ids.js

@@ -0,0 +1,18 @@
+function collectConfigFileIds(config) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of [
+    ...config.files1,
+    ...config.files2,
+    config.file1,
+    config.file2,
+    config.file3,
+    config.file4
+  ]) {
+    if (file) {
+      ids.add(file.id);
+    }
+  }
+  return [...ids];
+}
+
+export { collectConfigFileIds };

package/dist/src/application/resources/config/errors/codes.js

@@ -0,0 +1,5 @@
+const CONFIG_ERROR_CODES = {
+  NOT_FOUND: "CONFIG_NOT_FOUND"
+};
+
+export { CONFIG_ERROR_CODES };

package/dist/src/application/resources/config/errors/operation-errors.js

@@ -0,0 +1,11 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { CONFIG_ERROR_CODES } from './codes.js';
+
+class ConfigNotFoundError extends OperationError {
+  constructor() {
+    super({ code: CONFIG_ERROR_CODES.NOT_FOUND });
+    this.name = "ConfigNotFoundError";
+  }
+}
+
+export { ConfigNotFoundError };

package/dist/src/application/resources/config/operations/commands/update/cache.js

@@ -0,0 +1,24 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectConfigFileIds } from '../../../collect-config-file-ids.js';
+
+const createConfigUpdateInvalidationTags = (input, result) => {
+  const configs = [input.previous, result.data.config];
+  const fileIds = /* @__PURE__ */ new Set([
+    ...collectConfigFileIds(input.previous),
+    ...collectConfigFileIds(input.config)
+  ]);
+  const tags = [
+    createResourceTag("config"),
+    ...configs.flatMap((config) => [
+      createResourceTag("config", { id: config.id }),
+      createResourceTag("config", { slug: config.slug }),
+      createRelationTag("config", "translation", { id: config.id }),
+      // Relation: [File] files1, files2, file1, file2, file3, file4
+      createRelationTag("config", "file", { id: config.id })
+    ]),
+    ...[...fileIds].map((id) => createResourceTag("file", { id }))
+  ].flat();
+  return [...new Set(tags)];
+};
+
+export { createConfigUpdateInvalidationTags };

package/dist/src/application/resources/config/operations/commands/update/config-update-command.js

@@ -0,0 +1,36 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createConfigUpdateInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createConfigUpdateCommand(input) {
+  const { authorization, configQueryPort, configCommandPort, fileQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: createConfigUpdateInvalidationTags
+        }
+      },
+      async validate(input2) {
+        return validateInput({
+          input: input2,
+          configQueryPort,
+          fileQueryPort
+        });
+      }
+    },
+    async (input2) => {
+      const { previous: _, ...writeInput } = input2;
+      const config = await configCommandPort.update(writeInput);
+      return operationResult.success({
+        config
+      });
+    }
+  );
+}
+
+export { createConfigUpdateCommand };

package/dist/src/application/resources/config/operations/commands/update/validation/schema.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, singleItemSchema, multiItemsSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const nullableText = textSchema().nullable();
+const nullableDecimal = z.number().nullable();
+const nullableInteger = z.number().int().nullable();
+const data = z.array(z.unknown());
+const configUpdateInputSchema = () => z.object({
+  id: idSchema(),
+  config: z.object({
+    text1: nullableText.optional(),
+    text2: nullableText.optional(),
+    text3: nullableText.optional(),
+    text4: nullableText.optional(),
+    text5: nullableText.optional(),
+    text6: nullableText.optional(),
+    text7: nullableText.optional(),
+    text8: nullableText.optional(),
+    text9: nullableText.optional(),
+    text10: nullableText.optional(),
+    data1: data.optional(),
+    data2: data.optional(),
+    data3: data.optional(),
+    data4: data.optional(),
+    data5: data.optional(),
+    data6: data.optional(),
+    data7: data.optional(),
+    data8: data.optional(),
+    data9: data.optional(),
+    data10: data.optional(),
+    dec1: nullableDecimal.optional(),
+    dec2: nullableDecimal.optional(),
+    dec3: nullableDecimal.optional(),
+    dec4: nullableDecimal.optional(),
+    dec5: nullableDecimal.optional(),
+    dec6: nullableDecimal.optional(),
+    dec7: nullableDecimal.optional(),
+    dec8: nullableDecimal.optional(),
+    dec9: nullableDecimal.optional(),
+    dec10: nullableDecimal.optional(),
+    int1: nullableInteger.optional(),
+    int2: nullableInteger.optional(),
+    int3: nullableInteger.optional(),
+    int4: nullableInteger.optional(),
+    int5: nullableInteger.optional(),
+    int6: nullableInteger.optional(),
+    int7: nullableInteger.optional(),
+    int8: nullableInteger.optional(),
+    int9: nullableInteger.optional(),
+    int10: nullableInteger.optional(),
+    files1: multiItemsSchema(),
+    files2: multiItemsSchema(),
+    file1: singleItemSchema(),
+    file2: singleItemSchema(),
+    file3: singleItemSchema(),
+    file4: singleItemSchema(),
+    translations: z.array(
+      z.object({
+        locale: requiredTextSchema(),
+        i18nText1: nullableText,
+        i18nText2: nullableText,
+        i18nText3: nullableText,
+        i18nText4: nullableText,
+        i18nText5: nullableText,
+        i18nText6: nullableText,
+        i18nText7: nullableText,
+        i18nText8: nullableText,
+        i18nText9: nullableText,
+        i18nText10: nullableText,
+        i18nData1: data,
+        i18nData2: data,
+        i18nData3: data,
+        i18nData4: data,
+        i18nData5: data,
+        i18nData6: data,
+        i18nData7: data,
+        i18nData8: data,
+        i18nData9: data,
+        i18nData10: data
+      })
+    ).min(1).superRefine(addDuplicateLocaleIssues)
+  })
+});
+
+export { configUpdateInputSchema };

package/dist/src/application/resources/config/operations/commands/update/validation/validate-input.js

@@ -0,0 +1,33 @@
+import 'zod';
+import 'sitero-domain';
+import 'p-limit';
+import { assertFileExists } from '../../../../../file/constraints/assert-file-exists.js';
+import { ConfigNotFoundError } from '../../../../errors/operation-errors.js';
+import { configUpdateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, configQueryPort, fileQueryPort } = input;
+  const validatedInput = await configUpdateInputSchema().parseAsync(rawInput);
+  const previous = await configQueryPort.findDetail({
+    id: validatedInput.id
+  });
+  if (!previous) {
+    throw new ConfigNotFoundError();
+  }
+  const fileIds = new Set(
+    [
+      ...validatedInput.config.files1,
+      ...validatedInput.config.files2,
+      validatedInput.config.file1,
+      validatedInput.config.file2,
+      validatedInput.config.file3,
+      validatedInput.config.file4
+    ].filter((file) => !!file).map((file) => file.id)
+  );
+  await Promise.all(
+    [...fileIds].map((id) => assertFileExists({ id, fileQueryPort }))
+  );
+  return { ...validatedInput, previous };
+}
+
+export { validateInput };

package/dist/src/application/resources/config/operations/queries/find-detail/cache.js

@@ -0,0 +1,21 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectConfigFileIds } from '../../../collect-config-file-ids.js';
+
+const createConfigFindDetailCacheKey = (input) => {
+  return createCacheKey("config", "find-detail", { slug: input.slug });
+};
+const createConfigFindDetailCacheTags = (_, result) => {
+  const { config } = result.data;
+  const fileIds = collectConfigFileIds(config);
+  return [
+    createResourceTag("config", { id: config.id }),
+    createResourceTag("config", { slug: config.slug }),
+    createRelationTag("config", "translation", { id: config.id }),
+    // Relation: [File] files1, files2, file1, file2, file3, file4
+    ...fileIds.map((fileId) => createResourceTag("file", { id: fileId })),
+    createRelationTag("config", "file", { id: config.id })
+  ].flat();
+};
+
+export { createConfigFindDetailCacheKey, createConfigFindDetailCacheTags };

package/dist/src/application/resources/config/operations/queries/find-detail/config-find-detail-query.js

@@ -0,0 +1,40 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { ConfigNotFoundError } from '../../../errors/operation-errors.js';
+import { createConfigFindDetailCacheTags, createConfigFindDetailCacheKey } from './cache.js';
+import { configFindDetailInputSchema } from './validation/schema.js';
+
+function createConfigFindDetailQuery(input) {
+  const { authorization, configQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createConfigFindDetailCacheKey,
+          tags: createConfigFindDetailCacheTags
+        }
+      },
+      validate(input2) {
+        return configFindDetailInputSchema().parse(input2);
+      }
+    },
+    async (input2) => {
+      const config = await configQueryPort.findDetail({
+        slug: input2.slug
+      });
+      if (!config) {
+        return operationResult.failure(
+          new ConfigNotFoundError()
+        );
+      }
+      return operationResult.success({
+        config
+      });
+    }
+  );
+}
+
+export { createConfigFindDetailQuery };

package/dist/src/application/resources/config/operations/queries/find-detail/validation/schema.js

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

package/dist/src/application/resources/config/operations/queries/find-many/cache.js

@@ -0,0 +1,34 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectConfigFileIds } from '../../../collect-config-file-ids.js';
+
+const createConfigFindManyCacheKey = (input) => {
+  return createCacheKey("config", "find-many", {
+    slugs: normalizeSelection(input?.slugs)
+  });
+};
+const createConfigFindManyCacheTags = (input, result) => {
+  if (input?.slugs?.length === 0) {
+    return [];
+  }
+  const { configs } = result.data;
+  return [
+    ...new Set(
+      [
+        createResourceTag("config"),
+        ...configs.flatMap((config) => [
+          createResourceTag("config", { id: config.id }),
+          createResourceTag("config", { slug: config.slug }),
+          createRelationTag("config", "translation", { id: config.id }),
+          // Relation: [File] files1, files2, file1, file2, file3, file4
+          ...collectConfigFileIds(config).map(
+            (fileId) => createResourceTag("file", { id: fileId })
+          ),
+          createRelationTag("config", "file", { id: config.id })
+        ])
+      ].flat()
+    )
+  ];
+};
+
+export { createConfigFindManyCacheKey, createConfigFindManyCacheTags };

package/dist/src/application/resources/config/operations/queries/find-many/config-find-many-query.js

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createConfigFindManyCacheTags, createConfigFindManyCacheKey } from './cache.js';
+import { validateConfigFindManyInput } from './validation/validate-input.js';
+
+function createConfigFindManyQuery(input) {
+  const { configQueryPort, authorization } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createConfigFindManyCacheKey,
+          tags: createConfigFindManyCacheTags
+        }
+      },
+      validate(input2) {
+        return validateConfigFindManyInput(input2);
+      }
+    },
+    async (input2) => {
+      if (input2?.slugs?.length === 0) {
+        return operationResult.success({ configs: [] });
+      }
+      const configs = await configQueryPort.findMany(input2);
+      return operationResult.success({
+        configs
+      });
+    }
+  );
+}
+
+export { createConfigFindManyQuery };

package/dist/src/application/resources/config/operations/queries/find-many/validation/schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { slugSchema } from '../../../../../../conventions/validation/schema.js';
+
+const configFindManyInputSchema = () => z.object({
+  slugs: z.array(slugSchema()).optional()
+}).optional();
+
+export { configFindManyInputSchema };

package/dist/src/application/resources/config/operations/queries/find-many/validation/validate-input.js

@@ -0,0 +1,12 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { configFindManyInputSchema } from './schema.js';
+
+function validateConfigFindManyInput(input) {
+  const parsedInput = configFindManyInputSchema().parse(input);
+  if (!parsedInput || parsedInput.slugs === void 0) {
+    return void 0;
+  }
+  return { slugs: normalizeStringSelection(parsedInput.slugs) };
+}
+
+export { validateConfigFindManyInput };

package/dist/src/application/resources/config/operations/queries/find-public/cache.js

@@ -0,0 +1,18 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+import { collectConfigFileIds } from '../../../collect-config-file-ids.js';
+
+const createConfigFindPublicCacheKey = (input) => createCacheKey("config", "find-public", { slug: input.slug });
+const createConfigFindPublicCacheTags = (_, result) => {
+  const { config } = result.data;
+  const fileIds = collectConfigFileIds(config);
+  return [
+    createResourceTag("config", { id: config.id }),
+    createResourceTag("config", { slug: config.slug }),
+    createRelationTag("config", "translation", { id: config.id }),
+    ...fileIds.map((fileId) => createResourceTag("file", { id: fileId })),
+    createRelationTag("config", "file", { id: config.id })
+  ].flat();
+};
+
+export { createConfigFindPublicCacheKey, createConfigFindPublicCacheTags };

package/dist/src/application/resources/config/operations/queries/find-public/config-find-public-query.js

@@ -0,0 +1,43 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { ConfigNotFoundError } from '../../../errors/operation-errors.js';
+import { createConfigFindPublicCacheTags, createConfigFindPublicCacheKey } from './cache.js';
+import { configFindPublicInputSchema } from './validation/schema.js';
+
+function createConfigFindPublicQuery(input) {
+  const { configQueryPort } = input;
+  const publicSlugs = new Set(
+    input.publicSlugs.map((slug) => slug.trim()).filter(Boolean)
+  );
+  return createOperation(
+    {
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createConfigFindPublicCacheKey,
+          tags: createConfigFindPublicCacheTags
+        }
+      },
+      validate(input2) {
+        return configFindPublicInputSchema().parse(input2);
+      }
+    },
+    async (input2) => {
+      if (!publicSlugs.has(input2.slug)) {
+        return operationResult.failure(
+          new ConfigNotFoundError()
+        );
+      }
+      const config = await configQueryPort.findDetail({ slug: input2.slug });
+      if (!config) {
+        return operationResult.failure(
+          new ConfigNotFoundError()
+        );
+      }
+      return operationResult.success({ config });
+    }
+  );
+}
+
+export { createConfigFindPublicQuery };

package/dist/src/application/resources/config/operations/queries/find-public/validation/schema.js

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

package/dist/src/application/resources/file/constraints/assert-file-exists.js

@@ -0,0 +1,14 @@
+import { FileNotFoundError } from '../errors/operation-errors.js';
+
+async function assertFileExists(input) {
+  const { id, fileQueryPort } = input;
+  if (!id) {
+    return;
+  }
+  const file = await fileQueryPort.find({ id });
+  if (!file) {
+    throw new FileNotFoundError();
+  }
+}
+
+export { assertFileExists };

package/dist/src/application/resources/file/errors/codes.js

@@ -0,0 +1,20 @@
+const FILE_ERROR_CODES = {
+  NOT_FOUND: "FILE_NOT_FOUND",
+  DELETE_LOCKED: "FILE_DELETE_LOCKED",
+  DELETE_IN_USE: "FILE_DELETE_IN_USE",
+  DELETE_ALREADY_DELETED: "FILE_DELETE_ALREADY_DELETED",
+  UPDATE_DELETED: "FILE_UPDATE_DELETED",
+  REPLACE_CONTENT_DELETED: "FILE_REPLACE_CONTENT_DELETED",
+  REPLACE_CONTENT_LOCKED: "FILE_REPLACE_CONTENT_LOCKED",
+  REPLACE_CONTENT_IN_USE: "FILE_REPLACE_CONTENT_IN_USE",
+  REPLACE_CONTENT_SAME_KEY: "FILE_REPLACE_CONTENT_SAME_KEY",
+  RESTORE_NOT_DELETED: "FILE_RESTORE_NOT_DELETED",
+  PURGE_NOT_DELETED: "FILE_PURGE_NOT_DELETED",
+  PURGE_LOCKED: "FILE_PURGE_LOCKED",
+  PURGE_IN_USE: "FILE_PURGE_IN_USE"
+};
+const FILE_FIELD_ERROR_CODES = {
+  KEY_DUPLICATE: "validation.file.key.duplicate"
+};
+
+export { FILE_ERROR_CODES, FILE_FIELD_ERROR_CODES };

package/dist/src/application/resources/file/errors/operation-errors.js

@@ -0,0 +1,59 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { FILE_ERROR_CODES } from './codes.js';
+
+class FileNotFoundError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.NOT_FOUND });
+    this.name = "FileNotFoundError";
+  }
+}
+class FileDeleteLockedError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.DELETE_LOCKED });
+    this.name = "FileDeleteLockedError";
+  }
+}
+class FileDeleteInUseError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.DELETE_IN_USE });
+    this.name = "FileDeleteInUseError";
+  }
+}
+class FileDeleteAlreadyDeletedError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.DELETE_ALREADY_DELETED });
+    this.name = "FileDeleteAlreadyDeletedError";
+  }
+}
+class FileUpdateDeletedError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.UPDATE_DELETED });
+    this.name = "FileUpdateDeletedError";
+  }
+}
+class FileReplaceContentDeletedError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.REPLACE_CONTENT_DELETED });
+    this.name = "FileReplaceContentDeletedError";
+  }
+}
+class FileReplaceContentLockedError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.REPLACE_CONTENT_LOCKED });
+    this.name = "FileReplaceContentLockedError";
+  }
+}
+class FileReplaceContentInUseError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.REPLACE_CONTENT_IN_USE });
+    this.name = "FileReplaceContentInUseError";
+  }
+}
+class FileReplaceContentSameKeyError extends OperationError {
+  constructor() {
+    super({ code: FILE_ERROR_CODES.REPLACE_CONTENT_SAME_KEY });
+    this.name = "FileReplaceContentSameKeyError";
+  }
+}
+
+export { FileDeleteAlreadyDeletedError, FileDeleteInUseError, FileDeleteLockedError, FileNotFoundError, FileReplaceContentDeletedError, FileReplaceContentInUseError, FileReplaceContentLockedError, FileReplaceContentSameKeyError, FileUpdateDeletedError };

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

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

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

@@ -0,0 +1,41 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createFileCreateInvalidationTags } from './cache.js';
+import { registerUploadedFile } from '../register-uploaded-file.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createFileCreateCommand(input) {
+  const {
+    authorization,
+    fileCommandPort,
+    fileLookupPort,
+    storageRemovePort,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createFileCreateInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2, context) => {
+      const file = await registerUploadedFile({
+        file: input2,
+        context,
+        fileCommandPort,
+        fileLookupPort,
+        storageRemovePort,
+        observer
+      });
+      return operationResult.success({ file });
+    }
+  );
+}
+
+export { createFileCreateCommand };

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const fileCreateInputSchema = () => z.object({
+  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(),
+  translations: z.array(
+    z.object({
+      locale: requiredTextSchema(),
+      name: textSchema().nullable(),
+      alt: textSchema().nullable()
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+});
+
+export { fileCreateInputSchema };

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

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

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

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