sitero-server 0.0.1

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, singleItemSchema, emailSchema } from '../../../../../../conventions/validation/schema.js';
+
+const MIN_PASSWORD_LENGTH = 6;
+const adminCreateInputSchema = () => z.object({
+  // core
+  email: emailSchema(),
+  password: textSchema().min(MIN_PASSWORD_LENGTH).max(255),
+  preferredLocale: requiredTextSchema(),
+  receivesInquiryNotifications: z.boolean(),
+  // better seo
+  socialLinks: z.array(textSchema()),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  // File
+  avatarImage: singleItemSchema(),
+  // ----------------------------------------------------------------------------
+  // translation
+  // ----------------------------------------------------------------------------
+  translations: z.array(
+    z.object({
+      // core
+      locale: requiredTextSchema(),
+      // text
+      name: textSchema().nullable(),
+      // better seo
+      authorName: textSchema().nullable(),
+      description: textSchema().nullable(),
+      jobTitle: textSchema().nullable(),
+      url: textSchema().nullable(),
+      worksFor: textSchema().nullable(),
+      knowsAbout: z.array(textSchema()),
+      homeLocation: textSchema().nullable(),
+      nationality: textSchema().nullable()
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+});
+
+export { adminCreateInputSchema };

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

@@ -0,0 +1,22 @@
+import 'zod';
+import 'sitero-domain';
+import 'p-limit';
+import { assertFileExists } from '../../../../../file/constraints/assert-file-exists.js';
+import { assertAdminEmailUnique } from '../../../../constraints/assert-admin-email-unique.js';
+import { adminCreateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, adminQueryPort, fileQueryPort } = input;
+  const validatedInput = await adminCreateInputSchema().parseAsync(rawInput);
+  await assertAdminEmailUnique({
+    adminQueryPort,
+    email: validatedInput.email
+  });
+  await assertFileExists({
+    fileQueryPort,
+    id: validatedInput.avatarImage?.id
+  });
+  return validatedInput;
+}
+
+export { validateInput };

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

@@ -0,0 +1,31 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createAdminDeleteCacheTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createAdminDeleteCommand(input) {
+  const { authorization, adminCommandPort, adminQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: createAdminDeleteCacheTags
+        }
+      },
+      async validate(input2, { actor }) {
+        return validateInput({ input: input2, actor, adminQueryPort });
+      }
+    },
+    async (input2) => {
+      const admin = await adminCommandPort.delete(input2);
+      return operationResult.success({
+        admin
+      });
+    }
+  );
+}
+
+export { createAdminDeleteCommand };

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

@@ -0,0 +1,17 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createAdminDeleteCacheTags = (_, result) => {
+  const { admin } = result.data;
+  return [
+    createResourceTag("admin"),
+    createResourceTag("admin", { id: admin.id }),
+    createResourceTag("admin", { email: admin.email }),
+    // Relation: avatarImage [File]
+    createResourceTag("file", { id: admin.avatarImageId }),
+    createRelationTag("admin", "avatarImage", { id: admin.id }),
+    // Deleting an Admin sets its authored Posts' author relation to null.
+    createResourceTag("post")
+  ].flat();
+};
+
+export { createAdminDeleteCacheTags };

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

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

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

@@ -0,0 +1,23 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { AdminNotFoundError, AdminDeleteProtectedError, AdminDeleteForbiddenError } from '../../../../errors/operation-errors.js';
+import { adminDeleteInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, actor, adminQueryPort } = input;
+  const validatedInput = await adminDeleteInputSchema().parseAsync(rawInput);
+  const targetAdmin = await adminQueryPort.find({ id: validatedInput.id });
+  if (!targetAdmin) {
+    throw new AdminNotFoundError();
+  }
+  if (targetAdmin.role === ADMIN_ROLES.SUPER_ADMIN) {
+    throw new AdminDeleteProtectedError();
+  }
+  const isSelf = actor?.id === targetAdmin.id;
+  const canModifyOthers = actor?.role === ADMIN_ROLES.SUPER_ADMIN;
+  if (!isSelf && !canModifyOthers) {
+    throw new AdminDeleteForbiddenError();
+  }
+  return validatedInput;
+}
+
+export { validateInput };

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

@@ -0,0 +1,67 @@
+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 { createAdminUpdateCacheTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createAdminUpdateCommand(input) {
+  const {
+    authorization,
+    adminCommandPort,
+    adminQueryPort,
+    fileQueryPort,
+    adminVerificationEmail,
+    observer
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: {
+          tags: createAdminUpdateCacheTags
+        }
+      },
+      async validate(input2, { actor }) {
+        return validateInput({
+          input: input2,
+          actor,
+          adminQueryPort,
+          fileQueryPort
+        });
+      }
+    },
+    async (input2, context) => {
+      const {
+        previous: _previous,
+        shouldSendVerificationEmail,
+        ...preparedInput
+      } = input2;
+      const admin = await adminCommandPort.update(preparedInput);
+      if (shouldSendVerificationEmail) {
+        try {
+          await adminVerificationEmail.sender({
+            adminId: admin.id,
+            email: admin.email,
+            locale: admin.preferredLocale
+          });
+        } catch (error) {
+          await notifyObserverSafely(
+            observer,
+            (observer2) => observer2.onEffectError?.({
+              context,
+              effect: "email",
+              error
+            })
+          );
+        }
+      }
+      return operationResult.success({
+        admin
+      });
+    }
+  );
+}
+
+export { createAdminUpdateCommand };

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

@@ -0,0 +1,21 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createAdminUpdateCacheTags = (input, result) => {
+  const { admin } = result.data;
+  const admins = [input.previous, admin];
+  return [
+    ...new Set(
+      [
+        createResourceTag("admin"),
+        ...admins.flatMap((admin2) => [
+          createResourceTag("admin", { id: admin2.id }),
+          createResourceTag("admin", { email: admin2.email }),
+          createResourceTag("file", { id: admin2.avatarImageId }),
+          createRelationTag("admin", "avatarImage", { id: admin2.id })
+        ])
+      ].flat()
+    )
+  ];
+};
+
+export { createAdminUpdateCacheTags };

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, singleItemSchema, emailSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const adminUpdateInputSchema = () => z.object({
+  id: idSchema(),
+  // core
+  email: emailSchema(),
+  preferredLocale: requiredTextSchema(),
+  receivesInquiryNotifications: z.boolean(),
+  // better seo
+  socialLinks: z.array(textSchema()),
+  // ----------------------------------------------------------------------------
+  // relations
+  // ----------------------------------------------------------------------------
+  // File
+  avatarImage: singleItemSchema(),
+  // ----------------------------------------------------------------------------
+  // translation
+  // ----------------------------------------------------------------------------
+  translations: z.array(
+    z.object({
+      // core
+      locale: requiredTextSchema(),
+      // text
+      name: textSchema().nullable(),
+      // better seo
+      authorName: textSchema().nullable(),
+      description: textSchema().nullable(),
+      jobTitle: textSchema().nullable(),
+      url: textSchema().nullable(),
+      worksFor: textSchema().nullable(),
+      knowsAbout: z.array(textSchema()),
+      homeLocation: textSchema().nullable(),
+      nationality: textSchema().nullable()
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+});
+
+export { adminUpdateInputSchema };

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

@@ -0,0 +1,44 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import 'zod';
+import 'p-limit';
+import { assertFileExists } from '../../../../../file/constraints/assert-file-exists.js';
+import { assertAdminEmailUnique } from '../../../../constraints/assert-admin-email-unique.js';
+import { AdminNotFoundError, AdminUpdateForbiddenError } from '../../../../errors/operation-errors.js';
+import { adminUpdateInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const { input: rawInput, actor, adminQueryPort, fileQueryPort } = input;
+  const validatedInput = await adminUpdateInputSchema().parseAsync(rawInput);
+  const previous = await adminQueryPort.find({ id: validatedInput.id });
+  if (!previous) {
+    throw new AdminNotFoundError();
+  }
+  const isSelf = actor?.id === previous.id;
+  const canModifyOthers = actor?.role === ADMIN_ROLES.SUPER_ADMIN;
+  if (!isSelf && !canModifyOthers) {
+    throw new AdminUpdateForbiddenError();
+  }
+  const isUpdatingEmail = validatedInput.email !== previous.email;
+  if (isUpdatingEmail) {
+    await assertAdminEmailUnique({
+      adminQueryPort,
+      email: validatedInput.email,
+      excludeAdminId: previous.id
+    });
+  }
+  if (validatedInput.avatarImage?.id !== previous.avatarImageId) {
+    await assertFileExists({
+      fileQueryPort,
+      id: validatedInput.avatarImage?.id
+    });
+  }
+  return {
+    ...validatedInput,
+    previous,
+    role: previous.role,
+    emailVerifiedAt: isUpdatingEmail ? null : previous.emailVerifiedAt,
+    shouldSendVerificationEmail: isUpdatingEmail
+  };
+}
+
+export { validateInput };

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

@@ -0,0 +1,35 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminNotFoundError } from '../../../errors/operation-errors.js';
+import { omitAdminRefreshTokens } from '../../../projections/omit-admin-refresh-tokens.js';
+import { createAdminFindDetailCacheTags, createAdminFindDetailCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createAdminFindDetailQuery(input) {
+  const { authorization, adminQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createAdminFindDetailCacheKey,
+          tags: createAdminFindDetailCacheTags
+        }
+      },
+      validate(input2, { actor }) {
+        return validateInput({ input: input2, actor });
+      }
+    },
+    async (input2) => {
+      const admin = await adminQueryPort.findDetail(input2);
+      if (!admin) {
+        return operationResult.failure(new AdminNotFoundError());
+      }
+      return operationResult.success({ admin: omitAdminRefreshTokens(admin) });
+    }
+  );
+}
+
+export { createAdminFindDetailQuery };

package/dist/src/application/resources/admin/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';
+
+const createAdminFindDetailCacheKey = (input) => {
+  return createCacheKey("admin", "find-detail", {
+    id: input.id
+  });
+};
+const createAdminFindDetailCacheTags = (_, result) => {
+  const { admin } = result.data;
+  return [
+    createResourceTag("admin"),
+    createResourceTag("admin", { id: admin.id }),
+    createResourceTag("admin", { email: admin.email }),
+    // Relation: avatarImage [File]
+    createResourceTag("file", { id: admin.avatarImageId }),
+    createRelationTag("admin", "avatarImage", { id: admin.id })
+  ].flat();
+};
+
+export { createAdminFindDetailCacheKey, createAdminFindDetailCacheTags };

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

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

package/dist/src/application/resources/admin/operations/queries/find-detail/validation/validate-input.js

@@ -0,0 +1,11 @@
+import { assertAdminReadable } from '../../../../constraints/assert-admin-readable.js';
+import { adminFindDetailInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const { input: rawInput, actor } = input;
+  const validatedInput = adminFindDetailInputSchema().parse(rawInput);
+  assertAdminReadable({ actor, targetAdminId: validatedInput.id });
+  return validatedInput;
+}
+
+export { validateInput };

package/dist/src/application/resources/admin/operations/queries/find-list-cards/admin-find-list-cards-query.js

@@ -0,0 +1,34 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { omitAdminRefreshTokens } from '../../../projections/omit-admin-refresh-tokens.js';
+import { createAdminFindListCardsCacheTags, createAdminFindListCardsCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createAdminFindListCardsQuery(input) {
+  const { authorization, adminQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createAdminFindListCardsCacheKey,
+          tags: createAdminFindListCardsCacheTags
+        }
+      },
+      validate(input2, { actor }) {
+        return validateInput({ input: input2, actor });
+      }
+    },
+    async (input2) => {
+      const { items, total } = await adminQueryPort.findListCards(input2);
+      return operationResult.success({
+        items: items.map(omitAdminRefreshTokens),
+        total
+      });
+    }
+  );
+}
+
+export { createAdminFindListCardsQuery };

package/dist/src/application/resources/admin/operations/queries/find-list-cards/cache.js

@@ -0,0 +1,32 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createAdminFindListCardsCacheKey = (input) => {
+  return createCacheKey("admin", "find-list-cards", {
+    locale: input.locale,
+    searchString: input.searchString,
+    adminIds: normalizeSelection(input.adminIds),
+    currentRole: input.currentRole,
+    page: input.page,
+    pageSize: input.pageSize
+  });
+};
+const createAdminFindListCardsCacheTags = (_, result) => {
+  const { items } = result.data;
+  return [
+    ...new Set(
+      [
+        createResourceTag("admin"),
+        ...items.flatMap((admin) => [
+          createResourceTag("admin", { id: admin.id }),
+          createResourceTag("admin", { email: admin.email }),
+          // Relation: avatarImage [File]
+          createResourceTag("file", { id: admin.avatarImageId }),
+          createRelationTag("admin", "avatarImage", { id: admin.id })
+        ])
+      ].flat()
+    )
+  ];
+};
+
+export { createAdminFindListCardsCacheKey, createAdminFindListCardsCacheTags };

package/dist/src/application/resources/admin/operations/queries/find-list-cards/validation/schema.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { idSchema, textSchema, requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const adminFindListCardsInputSchema = () => z.object({
+  locale: requiredTextSchema(),
+  searchString: textSchema().optional(),
+  adminIds: z.array(idSchema()).optional(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional()
+});
+
+export { adminFindListCardsInputSchema };

package/dist/src/application/resources/admin/operations/queries/find-list-cards/validation/validate-input.js

@@ -0,0 +1,27 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { AdminReadForbiddenError } from '../../../../errors/operation-errors.js';
+import { adminFindListCardsInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const { input: rawInput, actor } = input;
+  const validatedInput = adminFindListCardsInputSchema().parse(rawInput);
+  if (!actor) {
+    throw new AdminReadForbiddenError();
+  }
+  const adminIds = validatedInput.adminIds ? normalizeStringSelection(validatedInput.adminIds) : void 0;
+  const preparedInput = {
+    ...validatedInput,
+    ...adminIds ? { adminIds } : {},
+    currentRole: actor.role === ADMIN_ROLES.SUPER_ADMIN ? ADMIN_ROLES.SUPER_ADMIN : ADMIN_ROLES.ADMIN
+  };
+  if (actor.role === ADMIN_ROLES.SUPER_ADMIN) {
+    return preparedInput;
+  }
+  return {
+    ...preparedInput,
+    adminIds: [actor.id]
+  };
+}
+
+export { validateInput };

package/dist/src/application/resources/admin/projections/omit-admin-refresh-tokens.js

@@ -0,0 +1,6 @@
+function omitAdminRefreshTokens(admin) {
+  const { adminRefreshTokens: _, ...safeAdmin } = admin;
+  return safeAdmin;
+}
+
+export { omitAdminRefreshTokens };

package/dist/src/application/resources/admin-refresh-token/errors/codes.js

@@ -0,0 +1,7 @@
+const ADMIN_REFRESH_TOKEN_ERROR_CODES = {
+  NOT_FOUND: "ADMIN_REFRESH_TOKEN_NOT_FOUND",
+  READ_FORBIDDEN: "ADMIN_REFRESH_TOKEN_READ_FORBIDDEN",
+  DELETE_FORBIDDEN: "ADMIN_REFRESH_TOKEN_DELETE_FORBIDDEN"
+};
+
+export { ADMIN_REFRESH_TOKEN_ERROR_CODES };

package/dist/src/application/resources/admin-refresh-token/errors/operation-errors.js

@@ -0,0 +1,23 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { ADMIN_REFRESH_TOKEN_ERROR_CODES } from './codes.js';
+
+class AdminRefreshTokenNotFoundError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_REFRESH_TOKEN_ERROR_CODES.NOT_FOUND });
+    this.name = "AdminRefreshTokenNotFoundError";
+  }
+}
+class AdminRefreshTokenReadForbiddenError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_REFRESH_TOKEN_ERROR_CODES.READ_FORBIDDEN });
+    this.name = "AdminRefreshTokenReadForbiddenError";
+  }
+}
+class AdminRefreshTokenDeleteForbiddenError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_REFRESH_TOKEN_ERROR_CODES.DELETE_FORBIDDEN });
+    this.name = "AdminRefreshTokenDeleteForbiddenError";
+  }
+}
+
+export { AdminRefreshTokenDeleteForbiddenError, AdminRefreshTokenNotFoundError, AdminRefreshTokenReadForbiddenError };

package/dist/src/application/resources/admin-refresh-token/operations/commands/delete/admin-refresh-token-delete-command.js

@@ -0,0 +1,43 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminRefreshTokenNotFoundError, AdminRefreshTokenDeleteForbiddenError } from '../../../errors/operation-errors.js';
+import { adminRefreshTokenDeleteInputSchema } from './validation/schema.js';
+
+function createAdminRefreshTokenDeleteCommand(input) {
+  const {
+    authorization,
+    adminRefreshTokenQueryPort,
+    adminRefreshTokenCommandPort
+  } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: { kind: "command" },
+      validate(input2) {
+        return adminRefreshTokenDeleteInputSchema().parse(input2);
+      }
+    },
+    async (input2, context) => {
+      const { actor } = context;
+      const adminRefreshToken = await adminRefreshTokenQueryPort.find({
+        id: input2.id
+      });
+      if (!adminRefreshToken) {
+        throw new AdminRefreshTokenNotFoundError();
+      }
+      const isSelf = actor.id === adminRefreshToken.adminId;
+      const canModifyOthers = actor.role === ADMIN_ROLES.SUPER_ADMIN;
+      if (!isSelf && !canModifyOthers) {
+        throw new AdminRefreshTokenDeleteForbiddenError();
+      }
+      await adminRefreshTokenCommandPort.delete({ id: input2.id });
+      return operationResult.success({
+        adminRefreshTokenId: input2.id
+      });
+    }
+  );
+}
+
+export { createAdminRefreshTokenDeleteCommand };

package/dist/src/application/resources/admin-refresh-token/operations/commands/delete/validation/schema.js

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

package/dist/src/application/resources/admin-refresh-token/operations/queries/find-many/admin-refresh-token-find-many-query.js

@@ -0,0 +1,40 @@
+import { ADMIN_ROLES } from 'sitero-domain';
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminRefreshTokenReadForbiddenError } from '../../../errors/operation-errors.js';
+import { adminRefreshTokenFindManyInputSchema } from './validation/schema.js';
+
+function createAdminRefreshTokenFindManyQuery(input) {
+  const { authorization, adminRefreshTokenQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: { kind: "query" },
+      validate(input2) {
+        return adminRefreshTokenFindManyInputSchema().parse(input2);
+      }
+    },
+    async (input2, context) => {
+      const { actor } = context;
+      const isSelf = actor.id === input2.adminId;
+      const canReadOthers = actor.role === ADMIN_ROLES.SUPER_ADMIN;
+      if (!isSelf && !canReadOthers) {
+        throw new AdminRefreshTokenReadForbiddenError();
+      }
+      const adminRefreshTokens = await adminRefreshTokenQueryPort.findMany({
+        adminId: input2.adminId
+      });
+      return operationResult.success({
+        adminRefreshTokens: adminRefreshTokens.map(
+          ({ tokenHash: _, ...adminRefreshToken }) => ({
+            ...adminRefreshToken,
+            isCurrent: adminRefreshToken.id === context.session?.id
+          })
+        )
+      });
+    }
+  );
+}
+
+export { createAdminRefreshTokenFindManyQuery };

package/dist/src/application/resources/admin-refresh-token/operations/queries/find-many/validation/schema.js

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