sitero-server 0.0.1

package/dist/export/index.js

@@ -0,0 +1,20 @@
+export { createSiteroServer } from '../src/composition/create-sitero-server.js';
+export { createNoopRateLimiterPort } from '../src/contracts/rate-limiter/port.js';
+export { OperationError } from '../src/contracts/operation/error.js';
+export { operationResult } from '../src/contracts/operation/result.js';
+export { AUTH_ADMIN_FIELD_ERROR_CODES } from '../src/application/features/authentication/admin/errors/codes.js';
+export { createOperation } from '../src/kernel/operation/operation.js';
+import 'zod';
+export { ExecutorError, RateLimitedExecutorError, UnauthenticatedExecutorError, UnauthorizedExecutorError, executorError } from '../src/kernel/executor/error.js';
+export { createOperationExecutor } from '../src/kernel/executor/executor.js';
+export { ADMIN_SIGN_IN_ERROR_CODES } from '../src/application/features/authentication/admin/operations/sign-in/errors.js';
+import 'sitero-domain';
+import 'p-limit';
+export { ADMIN_ME_ERROR_CODES } from '../src/application/features/authentication/admin/operations/me/errors.js';
+export { ADMIN_VERIFY_EMAIL_ERROR_CODES } from '../src/application/features/authentication/admin/operations/verify-email/errors.js';
+export { ADMIN_RESET_PASSWORD_ERROR_CODES } from '../src/application/features/authentication/admin/operations/reset-password/errors.js';
+export { ADMIN_CHANGE_PASSWORD_ERROR_CODES } from '../src/application/features/authentication/admin/operations/change-password/errors.js';
+export { isStorageFile } from '../src/contracts/storage/file.js';
+export { createAdminForgotPasswordEmailSender } from '../src/application/email/authentication/admin/forgot-password/send.js';
+export { createAdminVerificationEmailSender } from '../src/application/email/authentication/admin/verify-email/send.js';
+export { createNewInquiryEmailSender } from '../src/application/email/inquiry/new-inquiry/send.js';

package/dist/src/application/conventions/cache/cache-key.js

@@ -0,0 +1,24 @@
+import { normalizeStringSelection } from '../normalization/normalize-string-selection.js';
+import { LABEL } from './constants.js';
+
+const createCacheKey = (resource, query, ...inputs) => {
+  const resourcePart = [LABEL.resource, resource];
+  const queryPart = [LABEL.query, query];
+  return [
+    ...resourcePart,
+    ...queryPart,
+    ...inputs.flatMap(
+      (input) => Object.entries(input).flatMap(([key, value]) => [
+        key,
+        value == null ? LABEL.none : String(value)
+      ])
+    )
+  ].join(":");
+};
+const normalizeSelection = (values) => {
+  if (values === void 0) return LABEL.all;
+  if (!values.length) return LABEL.none;
+  return normalizeStringSelection(values).join(",");
+};
+
+export { createCacheKey, normalizeSelection };

package/dist/src/application/conventions/cache/cache-tag.js

@@ -0,0 +1,16 @@
+import { LABEL } from './constants.js';
+
+const createResourceTag = (resource, input) => {
+  if (!input) return [`${LABEL.resource}:${resource}`];
+  const [key, value] = Object.entries(input)[0] ?? [];
+  if (!key || value == null) return [];
+  return [`${LABEL.resource}:${resource}:${key}:${String(value)}`];
+};
+const createRelationTag = (resource, relation, input) => {
+  if (!input) return [`${LABEL.relation}:${resource}:${relation}`];
+  const [key, value] = Object.entries(input)[0] ?? [];
+  if (!key || value == null) return [];
+  return [`${LABEL.relation}:${resource}:${relation}:${key}:${String(value)}`];
+};
+
+export { createRelationTag, createResourceTag };

package/dist/src/application/conventions/cache/constants.js

@@ -0,0 +1,9 @@
+const LABEL = {
+  resource: "resource",
+  relation: "relation",
+  query: "query",
+  none: "__none",
+  all: "__all"
+};
+
+export { LABEL };

package/dist/src/application/conventions/normalization/normalize-string-selection.js

@@ -0,0 +1,5 @@
+function normalizeStringSelection(values) {
+  return [...new Set(values)].sort();
+}
+
+export { normalizeStringSelection };

package/dist/src/application/conventions/validation/add-duplicate-locale-issues.js

@@ -0,0 +1,22 @@
+import { VALIDATION_FIELD_ERROR_CODES } from './codes.js';
+
+function addDuplicateLocaleIssues(items, ctx) {
+  const indexesByLocale = /* @__PURE__ */ new Map();
+  for (const [index, item] of items.entries()) {
+    const indexes = indexesByLocale.get(item.locale) ?? [];
+    indexes.push(index);
+    indexesByLocale.set(item.locale, indexes);
+  }
+  for (const indexes of indexesByLocale.values()) {
+    if (indexes.length < 2) continue;
+    for (const index of indexes) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "locale"],
+        message: VALIDATION_FIELD_ERROR_CODES.LOCALE_DUPLICATE
+      });
+    }
+  }
+}
+
+export { addDuplicateLocaleIssues };

package/dist/src/application/conventions/validation/codes.js

@@ -0,0 +1,5 @@
+const VALIDATION_FIELD_ERROR_CODES = {
+  LOCALE_DUPLICATE: "validation.locale.duplicate"
+};
+
+export { VALIDATION_FIELD_ERROR_CODES };

package/dist/src/application/conventions/validation/schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const MAX_TEXT_LENGTH = 1e5;
+const textSchema = () => z.string().trim().max(MAX_TEXT_LENGTH);
+const requiredTextSchema = () => textSchema().min(1);
+const idSchema = () => requiredTextSchema();
+const slugSchema = () => requiredTextSchema();
+const itemSchema = () => z.object({ id: idSchema() });
+const singleItemSchema = () => itemSchema().nullable();
+const multiItemsSchema = () => z.array(itemSchema());
+const emailSchema = () => z.string().trim().max(254).pipe(z.email()).transform((email) => email.toLowerCase());
+
+export { emailSchema, idSchema, itemSchema, multiItemsSchema, requiredTextSchema, singleItemSchema, slugSchema, textSchema };

package/dist/src/application/email/authentication/admin/forgot-password/send.js

@@ -0,0 +1,31 @@
+function createAdminForgotPasswordEmailSender(input) {
+  const {
+    resetPasswordPathname,
+    createPasswordResetToken,
+    emailComposerPort,
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  } = input;
+  return async function sendAdminForgotPasswordEmail(input2) {
+    const { adminId, email, locale } = input2;
+    const passwordResetToken = createPasswordResetToken({ adminId });
+    const passwordResetUrl = emailLinkBuilderPort.build({
+      pathname: resetPasswordPathname,
+      query: {
+        passwordResetToken
+      }
+    });
+    const { subject, html, text } = await emailComposerPort.compose({
+      locale,
+      passwordResetUrl
+    });
+    await emailDeliveryPort.send({
+      to: email,
+      subject,
+      html,
+      text
+    });
+  };
+}
+
+export { createAdminForgotPasswordEmailSender };

package/dist/src/application/email/authentication/admin/verify-email/send.js

@@ -0,0 +1,32 @@
+function createAdminVerificationEmailSender(input) {
+  const {
+    verifyEmailPathname,
+    createEmailVerificationToken,
+    emailComposerPort,
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  } = input;
+  return async function sendAdminVerificationEmail(input2) {
+    const { adminId, email, locale } = input2;
+    const emailVerificationToken = createEmailVerificationToken({ adminId });
+    const emailVerificationUrl = emailLinkBuilderPort.build({
+      pathname: verifyEmailPathname,
+      query: {
+        email,
+        emailVerificationToken
+      }
+    });
+    const { subject, html, text } = await emailComposerPort.compose({
+      locale,
+      emailVerificationUrl
+    });
+    await emailDeliveryPort.send({
+      to: email,
+      subject,
+      html,
+      text
+    });
+  };
+}
+
+export { createAdminVerificationEmailSender };

package/dist/src/application/email/inquiry/new-inquiry/send.js

@@ -0,0 +1,18 @@
+function createNewInquiryEmailSender(input) {
+  const {
+    inquiryPathname,
+    emailComposerPort,
+    emailDeliveryPort,
+    emailLinkBuilderPort
+  } = input;
+  return async ({ email, locale }) => {
+    const url = emailLinkBuilderPort.build({ pathname: inquiryPathname });
+    const { subject, html, text } = await emailComposerPort.compose({
+      locale,
+      url
+    });
+    await emailDeliveryPort.send({ to: email, subject, html, text });
+  };
+}
+
+export { createNewInquiryEmailSender };

package/dist/src/application/features/authentication/admin/errors/codes.js

@@ -0,0 +1,5 @@
+const AUTH_ADMIN_FIELD_ERROR_CODES = {
+  PASSWORD_CONFIRM_MISMATCH: "validation.password.confirmation_mismatch"
+};
+
+export { AUTH_ADMIN_FIELD_ERROR_CODES };

package/dist/src/application/features/authentication/admin/operations/change-password/admin-change-password.js

@@ -0,0 +1,57 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminNotFoundError } from '../../../../../resources/admin/errors/operation-errors.js';
+import 'sitero-domain';
+import 'p-limit';
+import { AdminChangePasswordCredentialsInvalidError } from './errors.js';
+import { adminChangePasswordInputSchema } from './validation.js';
+
+function createAdminChangePassword(input) {
+  const {
+    authenticationTokenPort,
+    authenticationPasswordPort,
+    adminQueryPort,
+    adminAuthenticationCommandPort,
+    adminRefreshTokenCommandPort
+  } = input;
+  return createOperation(
+    {
+      authorization: { actorTypes: ["admin"] },
+      behavior: { kind: "command" },
+      async validate(input2) {
+        return adminChangePasswordInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2, context) => {
+      const admin = await adminQueryPort.findWithPasswordHash({
+        id: context.actor?.id
+      });
+      if (!admin) {
+        throw new AdminNotFoundError();
+      }
+      const isValid = await authenticationPasswordPort.verifyPassword({
+        passwordHash: admin.passwordHash,
+        password: input2.password
+      });
+      if (!isValid) {
+        throw new AdminChangePasswordCredentialsInvalidError();
+      }
+      const passwordHash = await authenticationPasswordPort.hashPassword(
+        input2.newPassword
+      );
+      await adminAuthenticationCommandPort.updatePasswordHash({
+        adminId: admin.id,
+        passwordHash
+      });
+      const excludeTokenHash = input2.refreshToken ? authenticationTokenPort.hashRefreshToken(input2.refreshToken) : void 0;
+      await adminRefreshTokenCommandPort.deleteMany({
+        adminId: admin.id,
+        ...excludeTokenHash ? { excludeTokenHash } : {}
+      });
+      return operationResult.success({});
+    }
+  );
+}
+
+export { createAdminChangePassword };

package/dist/src/application/features/authentication/admin/operations/change-password/errors.js

@@ -0,0 +1,13 @@
+import { OperationError } from '../../../../../../contracts/operation/error.js';
+
+const ADMIN_CHANGE_PASSWORD_ERROR_CODES = {
+  CREDENTIALS_INVALID: "AUTH_ADMIN_CHANGE_PASSWORD_CREDENTIALS_INVALID"
+};
+class AdminChangePasswordCredentialsInvalidError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_CHANGE_PASSWORD_ERROR_CODES.CREDENTIALS_INVALID });
+    this.name = "AdminChangePasswordCredentialsInvalidError";
+  }
+}
+
+export { ADMIN_CHANGE_PASSWORD_ERROR_CODES, AdminChangePasswordCredentialsInvalidError };

package/dist/src/application/features/authentication/admin/operations/change-password/validation.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { AUTH_ADMIN_FIELD_ERROR_CODES } from '../../errors/codes.js';
+
+const adminChangePasswordInputSchema = () => z.object({
+  password: z.string().min(1),
+  newPassword: z.string().min(8),
+  newPasswordConfirm: z.string().min(8),
+  refreshToken: z.string().optional()
+}).refine((input) => input.newPassword === input.newPasswordConfirm, {
+  path: ["newPasswordConfirm"],
+  message: AUTH_ADMIN_FIELD_ERROR_CODES.PASSWORD_CONFIRM_MISMATCH
+});
+
+export { adminChangePasswordInputSchema };

package/dist/src/application/features/authentication/admin/operations/email-unverified/admin-email-unverified.js

@@ -0,0 +1,45 @@
+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 { adminEmailUnverifiedInputSchema } from './validation.js';
+
+function createAdminEmailUnverified(input) {
+  const { adminQueryPort, adminVerificationEmail, observer, rateLimit } = input;
+  return createOperation(
+    {
+      behavior: { kind: "command" },
+      rateLimit,
+      async validate(input2) {
+        return adminEmailUnverifiedInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2, context) => {
+      const admin = await adminQueryPort.find({
+        email: input2.email
+      });
+      if (!admin) {
+        return operationResult.success({});
+      }
+      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({});
+    }
+  );
+}
+
+export { createAdminEmailUnverified };

package/dist/src/application/features/authentication/admin/operations/email-unverified/validation.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+const adminEmailUnverifiedInputSchema = () => z.object({
+  email: z.string().trim().toLowerCase().email()
+});
+
+export { adminEmailUnverifiedInputSchema };

package/dist/src/application/features/authentication/admin/operations/forgot-password/admin-forgot-password.js

@@ -0,0 +1,45 @@
+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 { adminForgotPasswordInputSchema } from './validation.js';
+
+function createAdminForgotPassword(input) {
+  const { adminQueryPort, adminForgotPasswordEmail, observer, rateLimit } = input;
+  return createOperation(
+    {
+      behavior: { kind: "command" },
+      rateLimit,
+      async validate(input2) {
+        return adminForgotPasswordInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2, context) => {
+      const admin = await adminQueryPort.find({
+        email: input2.email
+      });
+      if (!admin) {
+        return operationResult.success({});
+      }
+      try {
+        await adminForgotPasswordEmail.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({});
+    }
+  );
+}
+
+export { createAdminForgotPassword };

package/dist/src/application/features/authentication/admin/operations/forgot-password/validation.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+const adminForgotPasswordInputSchema = () => z.object({
+  email: z.string().trim().toLowerCase().email()
+});
+
+export { adminForgotPasswordInputSchema };

package/dist/src/application/features/authentication/admin/operations/me/admin-me.js

@@ -0,0 +1,37 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminNotFoundError } from '../../../../../resources/admin/errors/operation-errors.js';
+import 'sitero-domain';
+import 'p-limit';
+import { AdminMeUnauthorizedError } from './errors.js';
+
+function createAdminMe(input) {
+  const { adminQueryPort } = input;
+  return createOperation(
+    {
+      authorization: { actorTypes: ["admin"] },
+      behavior: { kind: "query" },
+      validate(input2) {
+        return input2;
+      }
+    },
+    async (input2, context) => {
+      const currentAdminId = context.actor?.id;
+      if (!currentAdminId || input2.adminId !== currentAdminId) {
+        throw new AdminMeUnauthorizedError();
+      }
+      const admin = await adminQueryPort.findDetail({
+        id: currentAdminId
+      });
+      if (!admin) {
+        return operationResult.failure(new AdminNotFoundError());
+      }
+      return operationResult.success({
+        admin
+      });
+    }
+  );
+}
+
+export { createAdminMe };

package/dist/src/application/features/authentication/admin/operations/me/errors.js

@@ -0,0 +1,13 @@
+import { OperationError } from '../../../../../../contracts/operation/error.js';
+
+const ADMIN_ME_ERROR_CODES = {
+  UNAUTHORIZED: "AUTH_ADMIN_ME_UNAUTHORIZED"
+};
+class AdminMeUnauthorizedError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_ME_ERROR_CODES.UNAUTHORIZED });
+    this.name = "AdminMeUnauthorizedError";
+  }
+}
+
+export { ADMIN_ME_ERROR_CODES, AdminMeUnauthorizedError };

package/dist/src/application/features/authentication/admin/operations/reset-password/admin-reset-password.js

@@ -0,0 +1,50 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { AdminResetPasswordTokenInvalidError } from './errors.js';
+import { adminResetPasswordInputSchema } from './validation.js';
+
+function createAdminResetPassword(input) {
+  const {
+    authenticationTokenPort,
+    authenticationPasswordPort,
+    adminQueryPort,
+    adminAuthenticationCommandPort,
+    adminRefreshTokenCommandPort,
+    rateLimit
+  } = input;
+  return createOperation(
+    {
+      behavior: { kind: "command" },
+      rateLimit,
+      async validate(input2) {
+        return adminResetPasswordInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2) => {
+      let adminId;
+      try {
+        ({ adminId } = authenticationTokenPort.verifyAdminPasswordResetToken({
+          token: input2.passwordResetToken
+        }));
+      } catch {
+        throw new AdminResetPasswordTokenInvalidError();
+      }
+      const admin = await adminQueryPort.find({ id: adminId });
+      if (!admin) {
+        throw new AdminResetPasswordTokenInvalidError();
+      }
+      const passwordHash = await authenticationPasswordPort.hashPassword(
+        input2.newPassword
+      );
+      await adminAuthenticationCommandPort.updatePasswordHash({
+        adminId,
+        passwordHash
+      });
+      await adminRefreshTokenCommandPort.deleteMany({ adminId });
+      return operationResult.success({});
+    }
+  );
+}
+
+export { createAdminResetPassword };

package/dist/src/application/features/authentication/admin/operations/reset-password/errors.js

@@ -0,0 +1,13 @@
+import { OperationError } from '../../../../../../contracts/operation/error.js';
+
+const ADMIN_RESET_PASSWORD_ERROR_CODES = {
+  TOKEN_INVALID: "AUTH_ADMIN_RESET_PASSWORD_TOKEN_INVALID"
+};
+class AdminResetPasswordTokenInvalidError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_RESET_PASSWORD_ERROR_CODES.TOKEN_INVALID });
+    this.name = "AdminResetPasswordTokenInvalidError";
+  }
+}
+
+export { ADMIN_RESET_PASSWORD_ERROR_CODES, AdminResetPasswordTokenInvalidError };

package/dist/src/application/features/authentication/admin/operations/reset-password/validation.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { AUTH_ADMIN_FIELD_ERROR_CODES } from '../../errors/codes.js';
+
+const adminResetPasswordInputSchema = () => z.object({
+  passwordResetToken: z.string().min(1),
+  newPassword: z.string().min(8),
+  newPasswordConfirm: z.string().min(8)
+}).refine((input) => input.newPassword === input.newPasswordConfirm, {
+  path: ["newPasswordConfirm"],
+  message: AUTH_ADMIN_FIELD_ERROR_CODES.PASSWORD_CONFIRM_MISMATCH
+});
+
+export { adminResetPasswordInputSchema };

package/dist/src/application/features/authentication/admin/operations/sign-in/admin-sign-in.js

@@ -0,0 +1,71 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createAuthenticationTokens } from '../../../token/create-authentication-tokens.js';
+import { AdminSignInCredentialsInvalidError } from './errors.js';
+import { adminSignInInputSchema } from './validation.js';
+
+function toAdminSafe(input) {
+  return input;
+}
+function createAdminSignIn(input) {
+  const {
+    refreshTokenTtlSeconds,
+    authenticationPasswordPort,
+    authenticationTokenPort,
+    adminQueryPort,
+    adminRefreshTokenCommandPort,
+    rateLimit
+  } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "command"
+      },
+      rateLimit,
+      validate(input2) {
+        return adminSignInInputSchema().parseAsync(input2);
+      }
+    },
+    async (input2) => {
+      const { email, password, ip } = input2;
+      const deviceInfo = input2.deviceInfo;
+      const normalizedEmail = email.trim().toLowerCase();
+      const admin = await adminQueryPort.findWithPasswordHash({
+        email: normalizedEmail
+      });
+      if (!admin) {
+        throw new AdminSignInCredentialsInvalidError();
+      }
+      const isValid = await authenticationPasswordPort.verifyPassword({
+        passwordHash: admin.passwordHash,
+        password
+      });
+      if (!isValid) {
+        throw new AdminSignInCredentialsInvalidError();
+      }
+      const { tokens } = await createAuthenticationTokens({
+        actor: { type: "admin", id: admin.id, role: admin.role },
+        refreshTokenTtlSeconds,
+        authenticationTokenPort,
+        createActorRefreshToken: async ({ expiresAt, tokenHash }) => {
+          return adminRefreshTokenCommandPort.create({
+            tokenHash,
+            email: admin.email,
+            ip,
+            deviceInfo: deviceInfo ?? null,
+            expiresAt,
+            adminId: admin.id
+          });
+        }
+      });
+      await adminRefreshTokenCommandPort.deleteManyExpired();
+      return operationResult.success({
+        admin: toAdminSafe(admin),
+        tokens
+      });
+    }
+  );
+}
+
+export { createAdminSignIn };

package/dist/src/application/features/authentication/admin/operations/sign-in/errors.js

@@ -0,0 +1,13 @@
+import { OperationError } from '../../../../../../contracts/operation/error.js';
+
+const ADMIN_SIGN_IN_ERROR_CODES = {
+  CREDENTIALS_INVALID: "AUTH_ADMIN_SIGN_IN_CREDENTIALS_INVALID"
+};
+class AdminSignInCredentialsInvalidError extends OperationError {
+  constructor() {
+    super({ code: ADMIN_SIGN_IN_ERROR_CODES.CREDENTIALS_INVALID });
+    this.name = "AdminSignInCredentialsInvalidError";
+  }
+}
+
+export { ADMIN_SIGN_IN_ERROR_CODES, AdminSignInCredentialsInvalidError };

package/dist/src/application/features/authentication/admin/operations/sign-in/validation.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+const adminSignInInputSchema = () => z.object({
+  email: z.string().trim().toLowerCase().email(),
+  password: z.string().min(1),
+  ip: z.string().min(1),
+  deviceInfo: z.any().nullable()
+});
+
+export { adminSignInInputSchema };