@yimingliao/cms 0.0.29 → 0.0.31

package/dist/{base-DbGnfZr6.d.ts → base-BUAGZ2YH.d.ts}

@@ -153,7 +153,7 @@ interface TocItem {
     text: string;
     id: string;
     level: 2 | 3 | 4 | 5 | 6;
-    children?: TocItem[];
+    children: TocItem[];
 }
 
 interface Post {

package/dist/{chunk-BTRPDDZJ.js → chunk-DWFOB4P3.js}

@@ -1,4 +1,4 @@
-import { mimeToExtension } from './chunk-YX7IPIGU.js';
+import { mimeToExtension } from './chunk-I2DBI3WJ.js';
 import path from 'path/posix';
 import { ulid } from 'ulid';
 

package/dist/{chunk-YX7IPIGU.js → chunk-I2DBI3WJ.js}

@@ -185,4 +185,24 @@ var result = {
   error
 };
 
-export { FILE_TYPES, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result };
+// src/shared/units.ts
+var SIZE = {
+  BYTE: 1,
+  KB: 1024,
+  MB: 1024 ** 2,
+  GB: 1024 ** 3,
+  TB: 1024 ** 4,
+  PB: 1024 ** 5
+};
+var TIME = {
+  MILLISECOND: 1,
+  SECOND: 1e3,
+  MINUTE: 60 * 1e3,
+  HOUR: 60 * 60 * 1e3,
+  DAY: 24 * 60 * 60 * 1e3,
+  WEEK: 7 * 24 * 60 * 60 * 1e3,
+  MONTH: 30 * 24 * 60 * 60 * 1e3,
+  YEAR: 365 * 24 * 60 * 60 * 1e3
+};
+
+export { FILE_TYPES, SIZE, TIME, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FolderFull } from './base-DbGnfZr6.js';
-export { A as ADMIN_ROLES, a as Admin, b as AdminCard, c as AdminFull, d as AdminRefreshToken, e as AdminRole, f as AdminSafe, g as AdminTranslation, h as Alternate, B as BaseTranslation, D as DeviceInfo, E as ExternalLink, i as FILE_TYPES, j as Faq, k as File, l as FileCard, m as FileFull, n as FileTranslation, o as FileType, p as Folder, M as MultiItems, P as POST_TYPES, q as Post, r as PostFull, s as PostListCard, t as PostTranslation, u as PostType, S as SeoMetadata, v as SingleItem, T as TocItem, w as Translation } from './base-DbGnfZr6.js';
+import { F as FolderFull } from './base-BUAGZ2YH.js';
+export { A as ADMIN_ROLES, a as Admin, b as AdminCard, c as AdminFull, d as AdminRefreshToken, e as AdminRole, f as AdminSafe, g as AdminTranslation, h as Alternate, B as BaseTranslation, D as DeviceInfo, E as ExternalLink, i as FILE_TYPES, j as Faq, k as File, l as FileCard, m as FileFull, n as FileTranslation, o as FileType, p as Folder, M as MultiItems, P as POST_TYPES, q as Post, r as PostFull, s as PostListCard, t as PostTranslation, u as PostType, S as SeoMetadata, v as SingleItem, T as TocItem, w as Translation } from './base-BUAGZ2YH.js';
 export { B as BlobFile } from './types-0oS1A2K5.js';
 import { E as ErrorDetail, S as SuccessResult, a as ErrorResult } from './types-DHlRoJwv.js';
 export { R as Result } from './types-DHlRoJwv.js';
@@ -44,4 +44,25 @@ declare const result: {
     error: typeof error;
 };
 
-export { ErrorDetail, ErrorResult, type ErrorResultParams, FolderFull, ROOT_FOLDER, ROOT_FOLDER_ID, ROOT_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY, SIMPLE_UPLOAD_FOLDER_NAME, SuccessResult, type SuccessResultParams, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result };
+declare const SIZE: {
+    readonly BYTE: 1;
+    readonly KB: 1024;
+    readonly MB: number;
+    readonly GB: number;
+    readonly TB: number;
+    readonly PB: number;
+};
+type SizeUnit = keyof typeof SIZE;
+declare const TIME: {
+    readonly MILLISECOND: 1;
+    readonly SECOND: 1000;
+    readonly MINUTE: number;
+    readonly HOUR: number;
+    readonly DAY: number;
+    readonly WEEK: number;
+    readonly MONTH: number;
+    readonly YEAR: number;
+};
+type TimeUnit = keyof typeof TIME;
+
+export { ErrorDetail, ErrorResult, type ErrorResultParams, FolderFull, ROOT_FOLDER, ROOT_FOLDER_ID, ROOT_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY, SIMPLE_UPLOAD_FOLDER_NAME, SIZE, type SizeUnit, SuccessResult, type SuccessResultParams, TIME, type TimeUnit, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result };

package/dist/index.js

@@ -1,2 +1,2 @@
 export { ADMIN_ROLES, POST_TYPES, ROOT_FOLDER, ROOT_FOLDER_ID, ROOT_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY, SIMPLE_UPLOAD_FOLDER_NAME } from './chunk-ZCOYQ5BG.js';
-export { FILE_TYPES, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result } from './chunk-YX7IPIGU.js';
+export { FILE_TYPES, SIZE, TIME, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension, result } from './chunk-I2DBI3WJ.js';

package/dist/server/index.d.ts

@@ -3,17 +3,21 @@ import { BinaryLike } from 'node:crypto';
 import { cookies } from 'next/headers';
 import Keyv from 'keyv';
 import { Logger } from 'logry';
-import { e as AdminRole, v as SingleItem, B as BaseTranslation, a as Admin, c as AdminFull, f as AdminSafe, D as DeviceInfo, d as AdminRefreshToken, k as File, m as FileFull, o as FileType, p as Folder, F as FolderFull, u as PostType, M as MultiItems, E as ExternalLink, j as Faq, T as TocItem, q as Post, s as PostListCard, t as PostTranslation, r as PostFull, S as SeoMetadata, g as AdminTranslation, n as FileTranslation, h as Alternate } from '../base-DbGnfZr6.js';
+import * as zod from 'zod';
+import zod__default, { z, ZodType } from 'zod';
+import { B as BlobFile } from '../types-0oS1A2K5.js';
+import * as zod_v4_core from 'zod/v4/core';
+import { T as TocItem, e as AdminRole, v as SingleItem, B as BaseTranslation, a as Admin, c as AdminFull, f as AdminSafe, D as DeviceInfo, d as AdminRefreshToken, k as File$1, m as FileFull, o as FileType, p as Folder, F as FolderFull, u as PostType, M as MultiItems, E as ExternalLink, j as Faq, q as Post, s as PostListCard, t as PostTranslation, r as PostFull, S as SeoMetadata, g as AdminTranslation, n as FileTranslation, h as Alternate } from '../base-BUAGZ2YH.js';
 import { BaseTranslator, LocaleMessages } from 'intor';
 import { S as SuccessResult, R as Result } from '../types-DHlRoJwv.js';
 import { NextResponse } from 'next/server';
 
-interface CreateJwtServiceOptions {
+interface CreateJwtServiceParams {
     defaultSecret: string;
     issuer?: string;
     audience?: string;
 }
-declare function createJwtService({ defaultSecret, ...options }: CreateJwtServiceOptions): {
+declare function createJwtService({ defaultSecret, ...options }: CreateJwtServiceParams): {
     sign: ({ payload, secret, expiresIn, }: {
         payload: object;
         secret: string;
@@ -30,10 +34,10 @@ declare function createArgon2Service(): {
     verify: (digest: string, password: string) => Promise<boolean>;
 };
 
-interface CreateCryptoServiceOptions {
+interface CreateCryptoServiceParams {
     defaultSecret: string;
 }
-declare function createCryptoService({ defaultSecret, }: CreateCryptoServiceOptions): {
+declare function createCryptoService({ defaultSecret, }: CreateCryptoServiceParams): {
     generateToken: () => string;
     hash: (value: BinaryLike) => string;
     hashBuffer: (value: BinaryLike) => Buffer;
@@ -74,12 +78,12 @@ declare function createCookieService(nextCookies: () => Promise<Awaited<ReturnTy
     }) => Promise<void>;
 };
 
-interface CreateServerCacheOptions {
+interface CreateServerCacheParams {
     redisUrl: string;
     namespace: string;
     keyDelimiter?: string;
 }
-declare function createCache({ redisUrl, namespace, keyDelimiter, }: CreateServerCacheOptions): Keyv<unknown>;
+declare function createCache({ redisUrl, namespace, keyDelimiter, }: CreateServerCacheParams): Keyv<unknown>;
 
 type RawCacheKey = string | Array<string | number | boolean | undefined | null>;
 declare const normalizeCacheKey: (key?: RawCacheKey, delimiter?: string) => string | null;
@@ -98,6 +102,92 @@ interface RateLimiterOptions {
 }
 declare function createIpRateLimiter(cache: Keyv<unknown>, appName: string): ({ key: rawKey, maxAttempts, timeWindow, }: RateLimiterOptions) => Promise<boolean>;
 
+type Scope = {
+    name: string;
+    value: string;
+    cast?: string;
+};
+type UniqueOptions = {
+    table: string;
+    column: string;
+    scope?: Scope[];
+    excludeSelf?: Scope;
+};
+declare function createUnique(prisma: any): (value: string, options: UniqueOptions) => Promise<boolean>;
+
+type ExistOptions = {
+    table: string;
+    column?: string;
+};
+declare function createExist(prisma: any): (value: string | number, options: ExistOptions) => Promise<boolean>;
+
+declare module "zod" {
+    interface ZodString {
+        unique(options: UniqueOptions): this;
+        exist(options: ExistOptions): this;
+        bcp47(): this;
+        ogLocale(): this;
+    }
+    interface ZodEmail {
+        unique(options: UniqueOptions): this;
+    }
+}
+declare function createZod({ unique, exist, }: {
+    unique: ReturnType<typeof createUnique>;
+    exist: ReturnType<typeof createExist>;
+}): typeof z;
+
+declare function createSchemas({ z, localeArray, exist, }: {
+    z: ReturnType<typeof createZod>;
+    localeArray: string[];
+    exist: ReturnType<typeof createExist>;
+}): {
+    text: () => zod__default.ZodString;
+    positiveNumber: () => zod__default.ZodPipe<zod__default.ZodTransform<number | undefined, unknown>, zod__default.ZodNumber>;
+    url: () => zod__default.ZodPipe<zod__default.ZodTransform<{} | null | undefined, unknown>, zod__default.ZodNullable<zod__default.ZodURL>>;
+    email: () => zod__default.ZodEmail;
+    password: () => zod__default.ZodString;
+    isoString: () => zod__default.ZodString;
+    array: <T extends ZodType>(schema: T) => zod__default.ZodPipe<zod__default.ZodArray<T>, zod__default.ZodTransform<NonNullable<zod__default.core.output<T>>[], zod__default.core.output<T>[]>>;
+    id: () => zod__default.ZodString;
+    key: () => zod__default.ZodString;
+    sha256Hash: () => zod__default.ZodString;
+    slug: () => zod__default.ZodString;
+    pathSegment: () => zod__default.ZodString;
+    locale: () => zod__default.ZodString;
+    singleItem: (options: ExistOptions) => zod__default.ZodNullable<zod__default.ZodObject<{
+        id: zod__default.ZodString;
+    }, zod__default.core.$strip>>;
+    multiItems: (options: ExistOptions) => zod__default.ZodPipe<zod__default.ZodArray<zod__default.ZodObject<{
+        id: zod__default.ZodString;
+    }, zod__default.core.$strip>>, zod__default.ZodTransform<{
+        id: string;
+    }[], {
+        id: string;
+    }[]>>;
+};
+
+declare function createFileSchema({ z, maxSizeInMb, }: {
+    z: ReturnType<typeof createZod>;
+    maxSizeInMb: number;
+}): ({ size, extensions, }: {
+    size?: number;
+    extensions?: string[];
+}) => zod.ZodPipe<zod.ZodCustom<File, File>, zod.ZodTransform<BlobFile, File>>;
+declare function createMultiFileSchema({ z, fileSchema, maxSizeInMb, }: {
+    z: ReturnType<typeof createZod>;
+    fileSchema: ReturnType<typeof createFileSchema>;
+    maxSizeInMb: number;
+}): ({ size, extensions, }?: {
+    size?: number;
+    extensions?: string[];
+}) => void;
+
+declare function createTocItemSchema({ z, schemas, }: {
+    z: ReturnType<typeof createZod>;
+    schemas: ReturnType<typeof createSchemas>;
+}): ZodType<TocItem, unknown, zod_v4_core.$ZodTypeInternals<TocItem, unknown>>;
+
 interface CreateParams$4 {
     email: string;
     role: AdminRole;
@@ -214,7 +304,7 @@ interface CreateParams$2 {
 }
 interface UpdateParams$2 {
     id: string;
-    file: File;
+    file: File$1;
     key: string;
     checksum: string;
     fileMeta: {
@@ -234,10 +324,10 @@ interface UpdateParams$2 {
 
 declare function createFileCommandRepository(prisma: any): {
     create: ({ fileMeta, folder, translations, ...params }: CreateParams$2) => Promise<FileFull>;
-    update: ({ file, id, fileMeta, folder, translations, ...params }: UpdateParams$2) => Promise<File>;
+    update: ({ file, id, fileMeta, folder, translations, ...params }: UpdateParams$2) => Promise<File$1>;
     softDelete: ({ id }: {
         id: string;
-    }) => Promise<File>;
+    }) => Promise<File$1>;
     softDeleteMany: ({ ids }: {
         ids: string[];
     }) => Promise<number>;
@@ -246,7 +336,7 @@ declare function createFileCommandRepository(prisma: any): {
     }) => Promise<number>;
     delete: ({ id }: {
         id: string;
-    }) => Promise<File>;
+    }) => Promise<File$1>;
 };
 
 interface FindListCardsParams$2 {
@@ -530,7 +620,7 @@ declare function createPostQueryRepository(prisma: any): {
         author: AdminSafe & {
             translations: AdminTranslation[];
         };
-        coverImage: File & {
+        coverImage: File$1 & {
             translations: FileTranslation[];
         };
     }) | null>;
@@ -602,25 +692,25 @@ declare const POST_ORDER_BY: ({
 type Action<D> = (translator: BaseTranslator<LocaleMessages>) => Promise<Omit<SuccessResult<D>, "success"> & {
     i18nKey?: string;
 }>;
-interface CreateExecuteActionOptions {
+interface CreateExecuteActionParams {
     initI18n: () => Promise<BaseTranslator<LocaleMessages>>;
     cacheResult: <T>({ key, ttl, load }: CacheResultOptions<T>) => Promise<T>;
     cache: Keyv<unknown>;
     logger: Logger;
 }
-interface ServerActionOptions {
+interface ServerActionParams {
     type?: "command" | "query";
     key?: RawCacheKey;
     ttl?: number;
 }
-declare function createExecuteAction({ initI18n, cacheResult, cache, logger, }: CreateExecuteActionOptions): <D = void>(fn: Action<D>, options?: ServerActionOptions) => Promise<Result<D>>;
+declare function createExecuteAction({ initI18n, cacheResult, cache, logger, }: CreateExecuteActionParams): <D = void>(fn: Action<D>, options?: ServerActionParams) => Promise<Result<D>>;
 
 type Api = (translator: BaseTranslator<LocaleMessages>) => Promise<NextResponse<unknown>>;
-interface CreateExecuteApiOptions {
+interface CreateExecuteApiParams {
     initI18n: () => Promise<BaseTranslator<LocaleMessages>>;
     logger: Logger;
 }
-declare function createExecuteApi({ initI18n, logger, }: CreateExecuteApiOptions): (fn: Api) => Promise<NextResponse<unknown>>;
+declare function createExecuteApi({ initI18n, logger }: CreateExecuteApiParams): (fn: Api) => Promise<NextResponse<unknown>>;
 
 interface CreateAuthUseCases {
     prisma: any;
@@ -682,7 +772,7 @@ declare function createAuthUseCases({ prisma, adminQueryRepository, adminRefresh
     }) => Promise<AdminSafe>;
 };
 
-interface CreateVerifyAccessTokenOptions {
+interface CreateVerifyAccessTokenParams {
     adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
     jwtService: ReturnType<typeof createJwtService>;
     cryptoService: ReturnType<typeof createCryptoService>;
@@ -692,11 +782,11 @@ interface CreateVerifyAccessTokenOptions {
         accessTokenSecret: string;
     };
 }
-declare function createVerifyAccessToken({ adminQueryRepository, jwtService, cryptoService, cookieService, config, }: CreateVerifyAccessTokenOptions): () => Promise<{
+declare function createVerifyAccessToken({ adminQueryRepository, jwtService, cryptoService, cookieService, config, }: CreateVerifyAccessTokenParams): () => Promise<{
     admin: AdminFull;
 } | null>;
 
-interface CreateVerifyRefreshTokenOptions {
+interface CreateVerifyRefreshTokenParams {
     adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
     adminRefreshTokenQueryRepository: ReturnType<typeof createAdminRefreshTokenQueryRepository>;
     cryptoService: ReturnType<typeof createCryptoService>;
@@ -705,19 +795,19 @@ interface CreateVerifyRefreshTokenOptions {
         refreshTokenName: string;
     };
 }
-declare function createVerifyRefreshToken({ adminQueryRepository, adminRefreshTokenQueryRepository, cryptoService, cookieService, config, }: CreateVerifyRefreshTokenOptions): () => Promise<{
+declare function createVerifyRefreshToken({ adminQueryRepository, adminRefreshTokenQueryRepository, cryptoService, cookieService, config, }: CreateVerifyRefreshTokenParams): () => Promise<{
     adminRefreshToken: AdminRefreshToken;
     admin: AdminFull;
 } | null>;
 
-interface CreateAuthMiddlewareOptions {
+interface CreateAuthMiddlewareParams {
     adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
     authUseCases: ReturnType<typeof createAuthUseCases>;
     verifyAccessToken: ReturnType<typeof createVerifyAccessToken>;
     verifyRefreshToken: ReturnType<typeof createVerifyRefreshToken>;
     headers: () => Promise<Headers>;
 }
-declare function createAuthMiddleware({ adminRefreshTokenCommandRepository, authUseCases, verifyAccessToken, verifyRefreshToken, headers, }: CreateAuthMiddlewareOptions): {
+declare function createAuthMiddleware({ adminRefreshTokenCommandRepository, authUseCases, verifyAccessToken, verifyRefreshToken, headers, }: CreateAuthMiddlewareParams): {
     authenticate(): Promise<AdminFull>;
 };
 
@@ -739,4 +829,4 @@ declare class ServerError extends Error {
     static internalServerError(): ServerError;
 }
 
-export { ADMIN_ORDER_BY, ORDER_BY, POST_ORDER_BY, type RawCacheKey, ServerError, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createCookieService, createCryptoService, createExecuteAction, createExecuteApi, createFileCommandRepository, createFileQueryRepository, createFolderCommandRepository, createFolderQueryRepository, createIpRateLimiter, createJwtService, createPostCommandRepository, createPostQueryRepository, createSeoMetadataCommandRepository, createVerifyAccessToken, createVerifyRefreshToken, normalizeCacheKey };
+export { ADMIN_ORDER_BY, ORDER_BY, POST_ORDER_BY, type RawCacheKey, ServerError, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createCookieService, createCryptoService, createExecuteAction, createExecuteApi, createExist, createFileCommandRepository, createFileQueryRepository, createFileSchema, createFolderCommandRepository, createFolderQueryRepository, createIpRateLimiter, createJwtService, createMultiFileSchema, createPostCommandRepository, createPostQueryRepository, createSchemas, createSeoMetadataCommandRepository, createTocItemSchema, createUnique, createVerifyAccessToken, createVerifyRefreshToken, createZod, normalizeCacheKey };

package/dist/server/index.js

@@ -1,13 +1,13 @@
 import { ADMIN_ROLES, ROOT_FOLDER_ID } from '../chunk-ZCOYQ5BG.js';
-import { result, mimeToExtension, classifyFileType } from '../chunk-YX7IPIGU.js';
+import { SIZE, result, mimeToExtension, classifyFileType } from '../chunk-I2DBI3WJ.js';
 import jwt from 'jsonwebtoken';
 import argon2 from 'argon2';
 import crypto, { timingSafeEqual } from 'crypto';
 import { headers } from 'next/headers';
 import KeyvRedis from '@keyv/redis';
 import Keyv from 'keyv';
+import { z, ZodError } from 'zod';
 import { ulid } from 'ulid';
-import { ZodError } from 'zod';
 import { NextResponse } from 'next/server';
 
 function createJwtService({
@@ -310,6 +310,300 @@ function createIpRateLimiter(cache, appName) {
   };
 }
 
+// src/server/infrastructure/zod/rules/unique.ts
+function createUnique(prisma) {
+  return async function unique(value, options) {
+    if (!value) return true;
+    let query = `
+    SELECT COUNT(*) AS count 
+    FROM ${options.table} 
+    WHERE ${options.column} = $1
+  `;
+    const params = [value];
+    const appendCondition = (op, sc) => {
+      const paramIndex = params.length + 1;
+      const cast = sc.cast ? `::"${sc.cast}"` : "";
+      query += ` AND ${sc.name} ${op} $${paramIndex}${cast}`;
+      params.push(sc.value);
+    };
+    if (options.scope) {
+      options.scope.forEach((sc) => appendCondition("=", sc));
+    }
+    if (options.excludeSelf) {
+      appendCondition("!=", options.excludeSelf);
+    }
+    try {
+      const result2 = await prisma.$queryRawUnsafe(
+        query,
+        ...params
+      );
+      return Number(result2[0]?.count || 0) === 0;
+    } catch (error) {
+      console.error("Unique check failed:", error);
+      return false;
+    }
+  };
+}
+
+// src/server/infrastructure/zod/rules/exist.ts
+function createExist(prisma) {
+  return async function exist(value, options) {
+    if (!value) return false;
+    const column = options.column || "id";
+    const query = `
+    SELECT COUNT(*) AS count 
+    FROM ${options.table} 
+    WHERE ${column} = $1
+  `;
+    try {
+      const result2 = await prisma.$queryRawUnsafe(
+        query,
+        value
+      );
+      const count = Number(result2[0]?.count || 0);
+      return count > 0;
+    } catch (error) {
+      console.error("Exist check failed:", error);
+      return false;
+    }
+  };
+}
+
+// src/server/infrastructure/zod/rules/bcp47.ts
+function bcp47(locale) {
+  if (typeof locale !== "string") return false;
+  const BCP47_REGEX = new RegExp(
+    "^[a-zA-Z]{2,3}(?:-[A-Z][a-z]{3})?" + // optional region
+    String.raw`(?:-(?:[A-Z]{2}|\d{3}))?` + // optional variants
+    String.raw`(?:-(?:[a-zA-Z0-9]{5,8}|\d[a-zA-Z0-9]{3}))*` + // optional extensions
+    "(?:-(?:[0-9A-WY-Za-wy-z]-[a-zA-Z0-9]{2,8}(?:-[a-zA-Z0-9]{2,8})*))*(?:-x(?:-[a-zA-Z0-9]{1,8})+)?$"
+  );
+  return BCP47_REGEX.test(locale);
+}
+
+// src/server/infrastructure/zod/rules/og-locale.ts
+function ogLocale(locale) {
+  if (typeof locale !== "string") return false;
+  const OG_LOCALE_REGEX = /^[a-z]{2}_[A-Z]{2}$/;
+  return OG_LOCALE_REGEX.test(locale);
+}
+
+// src/server/infrastructure/zod/create-zod.ts
+var patched = false;
+function createZod({
+  unique,
+  exist
+}) {
+  if (patched) return z;
+  patched = true;
+  const stringProto = z.ZodString.prototype;
+  const emailProto = z.ZodEmail.prototype;
+  Object.defineProperty(stringProto, "unique", {
+    configurable: true,
+    writable: false,
+    value: function(options) {
+      return this.refine(async (v) => unique(v, options), {
+        params: { i18nKey: "validator.unique" }
+      });
+    }
+  });
+  Object.defineProperty(stringProto, "exist", {
+    configurable: true,
+    writable: false,
+    value: function(options) {
+      return this.refine(async (v) => exist(v, options), {
+        params: { i18nKey: "validator.exist" }
+      });
+    }
+  });
+  Object.defineProperty(stringProto, "bcp47", {
+    configurable: true,
+    writable: false,
+    value: function() {
+      return this.refine((v) => bcp47(v), {
+        params: { i18nKey: "validator.bcp47" }
+      });
+    }
+  });
+  Object.defineProperty(stringProto, "ogLocale", {
+    configurable: true,
+    writable: false,
+    value: function() {
+      return this.refine((v) => ogLocale(v), {
+        params: { i18nKey: "validator.og-locale" }
+      });
+    }
+  });
+  Object.defineProperty(emailProto, "unique", {
+    configurable: true,
+    writable: false,
+    value: function(options) {
+      return this.refine(async (v) => unique(v, options), {
+        params: { i18nKey: "validator.unique" }
+      });
+    }
+  });
+  return z;
+}
+
+// src/server/infrastructure/zod/schemas/schemas.ts
+function createSchemas({
+  z: z2,
+  localeArray,
+  exist
+}) {
+  const trimmedString = () => z2.string().trim();
+  const MAX_NUMBER = 2147483647;
+  const MAX_STRING = 1e5;
+  const localeSet = new Set(localeArray);
+  function text() {
+    return trimmedString().max(MAX_STRING);
+  }
+  function positiveNumber() {
+    return z2.preprocess((val) => {
+      if (val == null || val === "") return;
+      const num = Number(String(val).trim());
+      return Number.isNaN(num) ? void 0 : num;
+    }, z2.number().min(0).max(MAX_NUMBER));
+  }
+  function url() {
+    return z2.preprocess((val) => {
+      if (typeof val === "string" && val.trim() === "" || val === null)
+        return null;
+      return val;
+    }, z2.url().max(2048).nullable());
+  }
+  function email() {
+    return z2.email().max(254).toLowerCase();
+  }
+  function password() {
+    return trimmedString().min(6).max(255);
+  }
+  function isoString() {
+    return trimmedString().regex(
+      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+    );
+  }
+  function array(schema) {
+    return z2.array(schema).max(100).transform(
+      (arr) => arr.filter((v) => v != null)
+    );
+  }
+  function id() {
+    return trimmedString().length(26).regex(/^[0-9A-Z]{26}$/);
+  }
+  function key() {
+    return trimmedString().max(1024);
+  }
+  function sha256Hash() {
+    return trimmedString().length(64).regex(/^[a-f0-9]{64}$/);
+  }
+  function slug() {
+    return trimmedString().regex(/^$|^[\p{L}0-9-_]+$/u).max(100);
+  }
+  function pathSegment() {
+    return trimmedString().min(1).regex(/^(?!\.\.?$)[^\u0000-\u001F/\\]+$/u).max(255);
+  }
+  function locale() {
+    return trimmedString().refine((val) => localeSet.has(val), {
+      error: "Invalid locale"
+    });
+  }
+  function singleItem(options) {
+    return z2.object({
+      id: id().refine((v) => exist(v, options), {
+        error: "Resource does not exist"
+      })
+    }).nullable();
+  }
+  function multiItems(options) {
+    return array(
+      z2.object({
+        id: id().refine((v) => exist(v, options), {
+          error: "Resource does not exist"
+        })
+      })
+    );
+  }
+  return {
+    // base
+    text,
+    positiveNumber,
+    url,
+    email,
+    password,
+    isoString,
+    array,
+    // resource related
+    id,
+    key,
+    sha256Hash,
+    slug,
+    pathSegment,
+    locale,
+    // item
+    singleItem,
+    multiItems
+  };
+}
+
+// src/server/infrastructure/zod/schemas/file.ts
+function createFileSchema({
+  z: z2,
+  maxSizeInMb
+}) {
+  return function fileSchema({
+    size = maxSizeInMb * SIZE.MB,
+    extensions = []
+  }) {
+    return z2.instanceof(File, { error: "Invalid file" }).refine((file) => file.size <= size, {
+      error: `File is too large, max ${size / SIZE.MB}MB`
+    }).refine(
+      (file) => {
+        if (extensions.length === 0) return true;
+        return extensions.some(
+          (ext) => file.name.toLocaleLowerCase().endsWith(ext)
+        );
+      },
+      { error: `Only ${extensions.join(", ")} files are allowed` }
+    ).transform((file) => file);
+  };
+}
+function createMultiFileSchema({
+  z: z2,
+  fileSchema,
+  maxSizeInMb
+}) {
+  return function multiFilesSchema({
+    size = maxSizeInMb * SIZE.MB,
+    extensions = []
+  } = {}) {
+    z2.array(fileSchema({ size, extensions }));
+  };
+}
+
+// src/server/infrastructure/zod/schemas/toc-item.ts
+function createTocItemSchema({
+  z: z2,
+  schemas
+}) {
+  const tocItem = z2.lazy(
+    () => z2.object({
+      text: schemas.text(),
+      id: schemas.text(),
+      level: z2.union([
+        z2.literal(2),
+        z2.literal(3),
+        z2.literal(4),
+        z2.literal(5),
+        z2.literal(6)
+      ]),
+      children: z2.array(tocItem).default([])
+    })
+  );
+  return tocItem;
+}
+
 // src/server/infrastructure/database/utils/connect.ts
 var ids = (items) => items.map(({ id }) => ({ id }));
 function connectOne(item) {
@@ -1521,10 +1815,7 @@ function createExecuteAction({
     }
   };
 }
-function createExecuteApi({
-  initI18n,
-  logger
-}) {
+function createExecuteApi({ initI18n, logger }) {
   return async function serverApi(fn) {
     const translator = await initI18n();
     try {
@@ -1753,4 +2044,4 @@ function createAuthUseCases({
   };
 }
 
-export { ADMIN_ORDER_BY, ORDER_BY, POST_ORDER_BY, ServerError, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createCookieService, createCryptoService, createExecuteAction, createExecuteApi, createFileCommandRepository, createFileQueryRepository, createFolderCommandRepository, createFolderQueryRepository, createIpRateLimiter, createJwtService, createPostCommandRepository, createPostQueryRepository, createSeoMetadataCommandRepository, createVerifyAccessToken, createVerifyRefreshToken, normalizeCacheKey };
+export { ADMIN_ORDER_BY, ORDER_BY, POST_ORDER_BY, ServerError, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createAuthMiddleware, createAuthUseCases, createCache, createCacheResult, createCookieService, createCryptoService, createExecuteAction, createExecuteApi, createExist, createFileCommandRepository, createFileQueryRepository, createFileSchema, createFolderCommandRepository, createFolderQueryRepository, createIpRateLimiter, createJwtService, createMultiFileSchema, createPostCommandRepository, createPostQueryRepository, createSchemas, createSeoMetadataCommandRepository, createTocItemSchema, createUnique, createVerifyAccessToken, createVerifyRefreshToken, createZod, normalizeCacheKey };

package/dist/storage/r2/index.d.ts

@@ -3,11 +3,11 @@ import { Logger } from 'logry';
 import { S as StorageService } from '../../types-J25u1G6t.js';
 import '../../types-0oS1A2K5.js';
 
-interface CreateR2ServiceOptions {
+interface CreateR2ServiceParams {
     r2Client: S3Client;
     bucketName: string;
     logger: Logger;
 }
-declare function createR2Service({ r2Client, bucketName, logger, }: CreateR2ServiceOptions): StorageService;
+declare function createR2Service({ r2Client, bucketName, logger, }: CreateR2ServiceParams): StorageService;
 
 export { createR2Service };

package/dist/storage/r2/index.js

@@ -1,5 +1,5 @@
-import { createObjectKey } from '../../chunk-BTRPDDZJ.js';
-import '../../chunk-YX7IPIGU.js';
+import { createObjectKey } from '../../chunk-DWFOB4P3.js';
+import '../../chunk-I2DBI3WJ.js';
 import { PutObjectCommand, DeleteObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
 
 function createR2Service({

package/dist/storage/sftp/index.d.ts

@@ -4,17 +4,17 @@ import SFTPClient from 'ssh2-sftp-client';
 import { S as StorageService } from '../../types-J25u1G6t.js';
 import '../../types-0oS1A2K5.js';
 
-interface CreateSftpServiceOptions {
+interface CreateSftpServiceParams {
     sftpPool: Pool<SFTPClient>;
     basePath: string;
     logger: Logger;
 }
-declare function createSftpService({ sftpPool, basePath, logger, }: CreateSftpServiceOptions): StorageService;
+declare function createSftpService({ sftpPool, basePath, logger, }: CreateSftpServiceParams): StorageService;
 
-interface CreateSftpPoolOptions {
+interface CreateSftpPoolParams {
     sftpClientOptions: SFTPClient.ConnectOptions;
     logger: Logger;
 }
-declare const createSftpPool: ({ sftpClientOptions, logger, }: CreateSftpPoolOptions) => Pool<SFTPClient>;
+declare const createSftpPool: ({ sftpClientOptions, logger, }: CreateSftpPoolParams) => Pool<SFTPClient>;
 
 export { createSftpPool, createSftpService };

package/dist/storage/sftp/index.js

@@ -1,5 +1,5 @@
-import { createObjectKey } from '../../chunk-BTRPDDZJ.js';
-import '../../chunk-YX7IPIGU.js';
+import { createObjectKey } from '../../chunk-DWFOB4P3.js';
+import '../../chunk-I2DBI3WJ.js';
 import path from 'path/posix';
 import { createPool } from 'generic-pool';
 import SFTPClient from 'ssh2-sftp-client';

package/package.json

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