@yimingliao/cms 0.0.51 → 0.0.52

package/dist/server/index.d.ts

@@ -102,7 +102,11 @@ interface RateLimiterOptions {
     maxAttempts?: number;
     timeWindow?: number;
 }
-declare function createIpRateLimiter(cache: Keyv<unknown>, appName: string): ({ key: rawKey, maxAttempts, timeWindow, }: RateLimiterOptions) => Promise<boolean>;
+declare function createIpRateLimiter({ appName, cache, headers, }: {
+    cache: Keyv<unknown>;
+    appName: string;
+    headers: () => Promise<Headers>;
+}): ({ key: rawKey, maxAttempts, timeWindow, }: RateLimiterOptions) => Promise<boolean>;
 
 type Scope = {
     name: string;
@@ -866,46 +870,57 @@ declare function createAuthMiddleware({ adminRefreshTokenCommandRepository, auth
     authenticate(): Promise<AdminFull>;
 };
 
+interface ActionContext {
+    services: {
+        cryptoService: ReturnType<typeof createCryptoService>;
+        argon2Service: ReturnType<typeof createArgon2Service>;
+        cookieService: ReturnType<typeof createCookieService>;
+    };
+    repositories: {
+        adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
+        adminCommandRepository: ReturnType<typeof createAdminCommandRepository>;
+        adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
+    };
+    useCases: {
+        authUseCases: ReturnType<typeof createAuthUseCases>;
+    };
+    middlewares: {
+        authMiddleware: ReturnType<typeof createAuthMiddleware>;
+    };
+    action: {
+        executeAction: ReturnType<typeof createExecuteAction>;
+        ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
+    };
+    emails: {
+        emailVerificationEmail: ReturnType<typeof createEmailVerificationEmail>;
+        forgotPasswordEmail: ReturnType<typeof createForgotPasswordEmail>;
+    };
+    http: {
+        headers: () => Promise<Headers>;
+    };
+    schemas: ReturnType<typeof createSchemas>;
+    config: {
+        accessTokenName: string;
+        refreshTokenName: string;
+    };
+}
+
 declare const signInValidator: (schemas: ReturnType<typeof createSchemas>) => zod.ZodObject<{
     email: zod.ZodEmail;
     password: zod.ZodString;
 }, zod_v4_core.$strip>;
 
 type SignInFormData = zod__default.infer<ReturnType<typeof signInValidator>>;
-interface CreateSignInActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    authUseCases: ReturnType<typeof createAuthUseCases>;
-    headers: () => Promise<Headers>;
-    schemas: ReturnType<typeof createSchemas>;
-    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
-    adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
-}
-declare function createSignInAction({ executeAction, ipRateLimiter, authUseCases, headers, schemas, adminQueryRepository, adminRefreshTokenCommandRepository, }: CreateSignInActionParams): ({ formData, deviceInfo, }: {
+declare function createSignInAction(ctx: ActionContext): ({ formData, deviceInfo, }: {
     formData: SignInFormData;
     deviceInfo: DeviceInfo;
 }) => Promise<Result<{
     admin: AdminFull;
 }>>;
 
-interface CreateSignOutActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    cookieService: ReturnType<typeof createCookieService>;
-    cryptoService: ReturnType<typeof createCryptoService>;
-    adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
-    config: {
-        accessTokenName: string;
-        refreshTokenName: string;
-    };
-}
-declare function createSignOutAction({ executeAction, cookieService, cryptoService, adminRefreshTokenCommandRepository, config, }: CreateSignOutActionParams): () => Promise<Result<void>>;
+declare function createSignOutAction(ctx: ActionContext): () => Promise<Result<void>>;
 
-interface CreateVerifyActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    authMiddleware: ReturnType<typeof createAuthMiddleware>;
-}
-declare function createVerifyAction({ executeAction, ipRateLimiter, authMiddleware, }: CreateVerifyActionParams): () => Promise<Result<{
+declare function createVerifyAction(ctx: ActionContext): () => Promise<Result<{
     admin: AdminFull;
 }>>;
 
@@ -916,14 +931,7 @@ declare const changePasswordValidator: (schemas: ReturnType<typeof createSchemas
 }, zod_v4_core.$strip>;
 
 type ChangePasswordFormData = zod__default.infer<ReturnType<typeof changePasswordValidator>>;
-interface CreateChangePasswordActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    authUseCases: ReturnType<typeof createAuthUseCases>;
-    authMiddleware: ReturnType<typeof createAuthMiddleware>;
-    schemas: ReturnType<typeof createSchemas>;
-}
-declare function createChangePasswordAction({ executeAction, ipRateLimiter, authUseCases, authMiddleware, schemas, }: CreateChangePasswordActionParams): ({ formData, }: {
+declare function createChangePasswordAction(ctx: ActionContext): ({ formData, }: {
     formData: ChangePasswordFormData;
 }) => Promise<Result<void>>;
 
@@ -933,14 +941,7 @@ declare const verifyEmailValidator: (schemas: ReturnType<typeof createSchemas>)
 }, zod_v4_core.$strip>;
 
 type VerifyEmailFormData = zod__default.infer<ReturnType<typeof verifyEmailValidator>>;
-interface CreateVerifyEmailActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    authUseCases: ReturnType<typeof createAuthUseCases>;
-    schemas: ReturnType<typeof createSchemas>;
-    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
-}
-declare function createVerifyEmailAction({ executeAction, ipRateLimiter, authUseCases, schemas, adminQueryRepository, }: CreateVerifyEmailActionParams): ({ formData, }: {
+declare function createVerifyEmailAction(ctx: ActionContext): ({ formData, }: {
     formData: VerifyEmailFormData;
 }) => Promise<Result<{
     admin: AdminSafe;
@@ -951,14 +952,7 @@ declare const emailUnverifiedValidator: (schemas: ReturnType<typeof createSchema
 }, zod_v4_core.$strip>;
 
 type EmailUnverifiedFormData = zod__default.infer<ReturnType<typeof emailUnverifiedValidator>>;
-interface CreateEmailUnverifiedActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    schemas: ReturnType<typeof createSchemas>;
-    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
-    emailVerificationEmail: ReturnType<typeof createEmailVerificationEmail>;
-}
-declare function createEmailUnverifiedAction({ executeAction, ipRateLimiter, schemas, adminQueryRepository, emailVerificationEmail, }: CreateEmailUnverifiedActionParams): ({ formData, }: {
+declare function createEmailUnverifiedAction(ctx: ActionContext): ({ formData, }: {
     formData: EmailUnverifiedFormData;
 }) => Promise<Result<void>>;
 
@@ -967,14 +961,7 @@ declare const forgetPasswordValidator: (schemas: ReturnType<typeof createSchemas
 }, zod_v4_core.$strip>;
 
 type ForgotPasswordFormData = zod__default.infer<ReturnType<typeof forgetPasswordValidator>>;
-interface CreateForgotPasswordActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    schemas: ReturnType<typeof createSchemas>;
-    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
-    forgotPasswordEmail: ReturnType<typeof createForgotPasswordEmail>;
-}
-declare function createForgotPasswordAction({ executeAction, ipRateLimiter, schemas, adminQueryRepository, forgotPasswordEmail, }: CreateForgotPasswordActionParams): ({ formData, }: {
+declare function createForgotPasswordAction(ctx: ActionContext): ({ formData, }: {
     formData: ForgotPasswordFormData;
 }) => Promise<Result<void>>;
 
@@ -985,13 +972,7 @@ declare const resetPasswordValidator: (schemas: ReturnType<typeof createSchemas>
 }, zod_v4_core.$strip>;
 
 type ResetPasswordFormData = zod__default.infer<ReturnType<typeof resetPasswordValidator>>;
-interface CreateResetPasswordActionParams {
-    executeAction: ReturnType<typeof createExecuteAction>;
-    ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
-    schemas: ReturnType<typeof createSchemas>;
-    authUseCases: ReturnType<typeof createAuthUseCases>;
-}
-declare function createResetPasswordAction({ executeAction, ipRateLimiter, schemas, authUseCases, }: CreateResetPasswordActionParams): ({ formData, }: {
+declare function createResetPasswordAction(ctx: ActionContext): ({ formData, }: {
     formData: ResetPasswordFormData;
 }) => Promise<Result<void>>;
 

package/dist/server/index.js

@@ -3,7 +3,7 @@ import { SIZE, result, mimeToExtension, classifyFileType } from '../chunk-YAUBKQ
 import jwt from 'jsonwebtoken';
 import argon2 from 'argon2';
 import crypto, { timingSafeEqual } from 'crypto';
-import { headers } from 'next/headers';
+import 'next/headers';
 import KeyvRedis from '@keyv/redis';
 import Keyv from 'keyv';
 import { z, ZodError } from 'zod';
@@ -287,7 +287,11 @@ var lua = `
     end
     return current
   `;
-function createIpRateLimiter(cache2, appName) {
+function createIpRateLimiter({
+  appName,
+  cache: cache2,
+  headers
+}) {
   return async function ipRateLimiter({
     key: rawKey,
     maxAttempts = DEFAULT_MAX_ATTEMPTS,
@@ -1922,7 +1926,7 @@ function createAuthMiddleware({
   authUseCases,
   verifyAccessToken,
   verifyRefreshToken,
-  headers: headers2
+  headers
 }) {
   const authMiddleware = {
     async authenticate() {
@@ -1937,7 +1941,7 @@ function createAuthMiddleware({
       await authUseCases.refreshTokens({
         admin,
         deviceInfo: adminRefreshToken.deviceInfo,
-        ip: (await headers2()).get("x-forwarded-for") || "unknown"
+        ip: (await headers()).get("x-forwarded-for") || "unknown"
       });
       return admin;
     }
@@ -2006,19 +2010,21 @@ var signInValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/sign-in/create-sign-in-action.ts
-function createSignInAction({
-  executeAction,
-  ipRateLimiter,
-  authUseCases,
-  headers: headers2,
-  schemas,
-  adminQueryRepository,
-  adminRefreshTokenCommandRepository
-}) {
+function createSignInAction(ctx) {
   return async function signInAction({
     formData,
     deviceInfo
   }) {
+    const {
+      repositories: {
+        adminQueryRepository,
+        adminRefreshTokenCommandRepository
+      },
+      useCases: { authUseCases },
+      action: { executeAction, ipRateLimiter },
+      http: { headers },
+      schemas
+    } = ctx;
     return executeAction(
       async () => {
         await ipRateLimiter({ key: ["sign-in"] });
@@ -2034,7 +2040,7 @@ function createSignInAction({
         await authUseCases.refreshTokens({
           admin,
           deviceInfo,
-          ip: (await headers2()).get("x-forwarded-for") || "unknown"
+          ip: (await headers()).get("x-forwarded-for") || "unknown"
         });
         await adminRefreshTokenCommandRepository.deleteManyByExpired();
         return {
@@ -2048,20 +2054,20 @@ function createSignInAction({
 }
 
 // src/server/interfaces/actions/auth/sign-out/create-sign-out-action.ts
-function createSignOutAction({
-  executeAction,
-  cookieService,
-  cryptoService,
-  adminRefreshTokenCommandRepository,
-  config
-}) {
+function createSignOutAction(ctx) {
+  const {
+    services: { cryptoService, cookieService },
+    repositories: { adminRefreshTokenCommandRepository },
+    action: { executeAction },
+    config: { accessTokenName, refreshTokenName }
+  } = ctx;
   return async function signOutAction() {
     return executeAction(
       async () => {
         let token;
         try {
           token = await cookieService.getSignedCookie({
-            name: config.refreshTokenName
+            name: refreshTokenName
           });
         } catch {
         }
@@ -2070,8 +2076,8 @@ function createSignOutAction({
             tokenHash: cryptoService.hash(token)
           });
         }
-        await cookieService.delete({ name: config.accessTokenName });
-        await cookieService.delete({ name: config.refreshTokenName });
+        await cookieService.delete({ name: accessTokenName });
+        await cookieService.delete({ name: refreshTokenName });
         return {
           i18nKey: "ok.sign-out-ok"
         };
@@ -2082,11 +2088,11 @@ function createSignOutAction({
 }
 
 // src/server/interfaces/actions/auth/verify/create-verify-action.ts
-function createVerifyAction({
-  executeAction,
-  ipRateLimiter,
-  authMiddleware
-}) {
+function createVerifyAction(ctx) {
+  const {
+    middlewares: { authMiddleware },
+    action: { executeAction, ipRateLimiter }
+  } = ctx;
   return async function verifyAction() {
     return executeAction(async () => {
       await ipRateLimiter({ key: ["verify"], maxAttempts: 60 });
@@ -2119,16 +2125,16 @@ var changePasswordValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/change-password/create-change-password-action.ts
-function createChangePasswordAction({
-  executeAction,
-  ipRateLimiter,
-  authUseCases,
-  authMiddleware,
-  schemas
-}) {
+function createChangePasswordAction(ctx) {
   return async function changePasswordAction({
     formData
   }) {
+    const {
+      action: { executeAction, ipRateLimiter },
+      useCases: { authUseCases },
+      middlewares: { authMiddleware },
+      schemas
+    } = ctx;
     return executeAction(
       async () => {
         await ipRateLimiter({ key: ["change-password"] });
@@ -2152,16 +2158,16 @@ var verifyEmailValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/verify-email/create-verify-email-action.ts
-function createVerifyEmailAction({
-  executeAction,
-  ipRateLimiter,
-  authUseCases,
-  schemas,
-  adminQueryRepository
-}) {
+function createVerifyEmailAction(ctx) {
   return async function verifyEmailAction({
     formData
   }) {
+    const {
+      repositories: { adminQueryRepository },
+      useCases: { authUseCases },
+      action: { executeAction, ipRateLimiter },
+      schemas
+    } = ctx;
     return executeAction(
       async () => {
         await ipRateLimiter({ key: ["verify-email"] });
@@ -2188,16 +2194,16 @@ var emailUnverifiedValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/email-unverifired/create-email-unverifired-action.ts
-function createEmailUnverifiedAction({
-  executeAction,
-  ipRateLimiter,
-  schemas,
-  adminQueryRepository,
-  emailVerificationEmail
-}) {
+function createEmailUnverifiedAction(ctx) {
   return async function emailUnverifiedAction({
     formData
   }) {
+    const {
+      repositories: { adminQueryRepository },
+      action: { executeAction, ipRateLimiter },
+      emails: { emailVerificationEmail },
+      schemas
+    } = ctx;
     return executeAction(
       async (translator) => {
         await ipRateLimiter({
@@ -2224,16 +2230,16 @@ var forgetPasswordValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/forgot-password/create-forgot-password-action.ts
-function createForgotPasswordAction({
-  executeAction,
-  ipRateLimiter,
-  schemas,
-  adminQueryRepository,
-  forgotPasswordEmail
-}) {
+function createForgotPasswordAction(ctx) {
   return async function forgotPasswordAction({
     formData
   }) {
+    const {
+      repositories: { adminQueryRepository },
+      action: { executeAction, ipRateLimiter },
+      emails: { forgotPasswordEmail },
+      schemas
+    } = ctx;
     return executeAction(
       async (translator) => {
         await ipRateLimiter({
@@ -2275,15 +2281,15 @@ var resetPasswordValidator = (schemas) => schemas.z.object({
 });
 
 // src/server/interfaces/actions/auth/reset-password/create-reset-password-action.ts
-function createResetPasswordAction({
-  executeAction,
-  ipRateLimiter,
-  schemas,
-  authUseCases
-}) {
+function createResetPasswordAction(ctx) {
   return async function ResetPasswordAction({
     formData
   }) {
+    const {
+      useCases: { authUseCases },
+      action: { executeAction, ipRateLimiter },
+      schemas
+    } = ctx;
     return executeAction(
       async () => {
         await ipRateLimiter({ key: ["reset-password"] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yimingliao/cms",
-  "version": "0.0.51",
+  "version": "0.0.52",
   "author": "Yiming Liao",
   "license": "MIT",
   "type": "module",