@yimingliao/cms 0.0.51 → 0.0.53

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>>;
 
@@ -1013,4 +994,4 @@ declare class ServerError extends Error {
     static internalServerError(): ServerError;
 }
 
-export { ADMIN_ORDER_BY, type ChangePasswordFormData, type EmailUnverifiedFormData, type ForgotPasswordFormData, ORDER_BY, POST_ORDER_BY, type RawCacheKey, type ResetPasswordFormData, ServerError, type SignInFormData, type VerifyEmailFormData, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createChangePasswordAction, createCookieService, createCryptoService, createEmailUnverifiedAction, createEmailVerificationEmail, createExecuteAction, createExecuteApi, createExist, createFileCommandRepository, createFileQueryRepository, createFileSchema, createFolderCommandRepository, createFolderQueryRepository, createForgotPasswordAction, createForgotPasswordEmail, createIpRateLimiter, createJwtService, createMultiFileSchema, createPostCommandRepository, createPostQueryRepository, createRenderEmailTemplate, createResetPasswordAction, createSchemas, createSendEmail, createSeoMetadataCommandRepository, createSignInAction, createSignOutAction, createTocItemSchema, createTransporter, createUnique, createVerifyAccessToken, createVerifyAction, createVerifyEmailAction, createVerifyRefreshToken, createZod, normalizeCacheKey };
+export { ADMIN_ORDER_BY, type ActionContext, type ChangePasswordFormData, type EmailUnverifiedFormData, type ForgotPasswordFormData, ORDER_BY, POST_ORDER_BY, type RawCacheKey, type ResetPasswordFormData, ServerError, type SignInFormData, type VerifyEmailFormData, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createChangePasswordAction, createCookieService, createCryptoService, createEmailUnverifiedAction, createEmailVerificationEmail, createExecuteAction, createExecuteApi, createExist, createFileCommandRepository, createFileQueryRepository, createFileSchema, createFolderCommandRepository, createFolderQueryRepository, createForgotPasswordAction, createForgotPasswordEmail, createIpRateLimiter, createJwtService, createMultiFileSchema, createPostCommandRepository, createPostQueryRepository, createRenderEmailTemplate, createResetPasswordAction, createSchemas, createSendEmail, createSeoMetadataCommandRepository, createSignInAction, createSignOutAction, createTocItemSchema, createTransporter, createUnique, createVerifyAccessToken, createVerifyAction, createVerifyEmailAction, createVerifyRefreshToken, createZod, normalizeCacheKey };

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.53",
   "author": "Yiming Liao",
   "license": "MIT",
   "type": "module",