@adlas/create-app 1.0.0

package/templates/boilerplate/utils/file/index.ts

@@ -0,0 +1,3 @@
+export * from './fileConfig';
+export * from './fileValidation';
+export * from './imageCompression';

package/templates/boilerplate/utils/helpers.ts

@@ -0,0 +1,55 @@
+import { siteConfig } from '@/config/site';
+
+export const isBrowser = (): boolean => typeof window !== 'undefined';
+
+export const isServer = (): boolean => typeof window === 'undefined';
+
+export const formatPrice = (
+  price: string | number,
+  locale: string = siteConfig.locales[1] as string,
+) => {
+  const priceNum = typeof price === 'string' ? Number.parseFloat(price) : price;
+
+  if (locale === siteConfig.locales[1]) {
+    const formatted = new Intl.NumberFormat('de-DE', {
+      style: 'currency',
+      currency: 'EUR',
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2,
+    }).format(priceNum);
+    return formatted;
+  }
+
+  const formatted = new Intl.NumberFormat('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  }).format(priceNum);
+  return `${formatted} €`;
+};
+
+export const formatLabel = (str: string) => {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+};
+// Format date
+export const formatDate = (dateString: string, locale: string) => {
+  // Return empty string if dateString is empty or invalid
+  if (!dateString || dateString.trim() === '') {
+    return '';
+  }
+
+  const date = new Date(dateString);
+
+  // Check if date is invalid
+  if (Number.isNaN(date.getTime())) {
+    return '';
+  }
+
+  return new Intl.DateTimeFormat(locale === siteConfig.locales[0] ? 'en-US' : 'de-DE', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  }).format(date);
+};

package/templates/boilerplate/validations/auth.validation.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+
+import {
+  confirmPasswordValidationI18n,
+  emailValidationI18n,
+  firstNameValidationI18n,
+  lastNameValidationI18n,
+  passwordValidationI18n,
+} from './commonValidations';
+
+// ==================== Authentication Validation Schemas with i18n ====================
+
+/**
+ * Login validation schema with i18n support
+ */
+export const LoginValidationI18n = z.object({
+  email: emailValidationI18n,
+  password: passwordValidationI18n,
+});
+
+/**
+ * Register person validation schema with i18n support
+ */
+const _RegisterPersonValidationI18n = z
+  .object({
+    firstName: firstNameValidationI18n,
+    lastName: lastNameValidationI18n,
+    email: emailValidationI18n,
+    password: passwordValidationI18n,
+    confirmPassword: confirmPasswordValidationI18n,
+  })
+  .refine(data => data.password === data.confirmPassword, {
+    path: ['confirmPassword'],
+    message: 'Validations.Auth.passwordsDoNotMatch',
+  });
+
+/**
+ * Basic info validation schema with i18n support
+ * Used for the first step of registration
+ */
+export const PersonBasicInfoValidationI18n = z.object({
+  firstName: firstNameValidationI18n,
+  lastName: lastNameValidationI18n,
+  email: emailValidationI18n,
+});
+
+/**
+ * Password step validation schema with i18n support
+ * Used for the second step of registration
+ */
+export const PersonPasswordValidationI18n = z
+  .object({
+    password: passwordValidationI18n,
+    confirmPassword: confirmPasswordValidationI18n,
+  })
+  .refine(data => data.password === data.confirmPassword, {
+    path: ['confirmPassword'],
+    message: 'Validations.Auth.passwordsDoNotMatch',
+  });
+
+/**
+ * Forgot password request validation schema with i18n support
+ */
+export const ForgotPasswordRequestValidationI18n = z.object({
+  email: emailValidationI18n,
+});
+
+/**
+ * Reset password validation schema with i18n support
+ */
+export const ResetPasswordValidationI18n = z
+  .object({
+    email: emailValidationI18n,
+    token: z.string().min(1, { message: 'Validations.Auth.tokenRequired' }),
+    password: passwordValidationI18n,
+    confirmPassword: confirmPasswordValidationI18n,
+  })
+  .refine(data => data.password === data.confirmPassword, {
+    path: ['confirmPassword'],
+    message: 'Validations.Auth.passwordsDoNotMatch',
+  });
+
+// ==================== Type Exports ====================
+
+export type LoginValidationI18nType = z.infer<typeof LoginValidationI18n>;
+export type RegisterPersonValidationI18nType = z.infer<typeof _RegisterPersonValidationI18n>;
+export type PersonBasicInfoValidationI18nType = z.infer<typeof PersonBasicInfoValidationI18n>;
+export type PersonPasswordValidationI18nType = z.infer<typeof PersonPasswordValidationI18n>;
+export type ForgotPasswordRequestValidationI18nType = z.infer<
+  typeof ForgotPasswordRequestValidationI18n
+>;
+export type ResetPasswordValidationI18nType = z.infer<typeof ResetPasswordValidationI18n>;

package/templates/boilerplate/validations/commonValidations.ts

@@ -0,0 +1,258 @@
+import type { useTranslations } from 'next-intl';
+
+import { z } from 'zod';
+
+import type { FileValidationError } from '@/components/ui';
+
+// ==================== Types ====================
+
+/**
+ * Type for field validation (used by Form component)
+ */
+export type FormFieldValidation = {
+  required?: boolean;
+  pattern?: RegExp;
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  validate?: (value: unknown) => boolean | string;
+};
+
+// ==================== Common Validation Schemas with i18n ====================
+
+/**
+ * Email validation with i18n support
+ */
+export const emailValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .toLowerCase()
+  .regex(/^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/, {
+    message: 'Validations.email',
+  });
+
+/**
+ * Password validation with i18n support
+ * Must match validatePasswordRequirements function
+ */
+export const passwordValidationI18n = z
+  .string()
+  .min(8, { message: 'Validations.Auth.passwordMinLength' })
+  .max(50, { message: 'Validations.Auth.passwordMaxLength' })
+  .regex(/[A-Z]/, { message: 'Validations.Auth.passwordUppercase' })
+  .regex(/[a-z]/, { message: 'Validations.Auth.passwordLowercase' })
+  .regex(/\d/, { message: 'Validations.Auth.passwordNumber' })
+  .regex(/[@#$%]/, { message: 'Validations.Auth.passwordSpecialChar' })
+  .regex(/^[a-z0-9@#$%]*$/i, { message: 'Validations.Auth.passwordEnglishOnly' });
+
+/**
+ * Confirm password validation with i18n support
+ */
+export const confirmPasswordValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.Auth.confirmPasswordRequired' });
+
+/**
+ * First name validation with i18n support
+ */
+export const firstNameValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .min(2, { message: 'Validations.minLength' })
+  .max(50, { message: 'Validations.maxLength' })
+  .regex(/^[a-z\s\-']+$/i, {
+    message: 'Validations.invalidFormat',
+  });
+
+/**
+ * Last name validation with i18n support
+ */
+export const lastNameValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .min(2, { message: 'Validations.minLength' })
+  .max(50, { message: 'Validations.maxLength' })
+  .regex(/^[a-z\s\-']+$/i, {
+    message: 'Validations.invalidFormat',
+  });
+
+/**
+ * Phone number validation with i18n support
+ */
+export const phoneValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .regex(/^\+?[\d\s\-()]+$/, {
+    message: 'Validations.invalidFormat',
+  })
+  .min(10, { message: 'Validations.minLength' })
+  .max(20, { message: 'Validations.maxLength' });
+
+/**
+ * Street address validation with i18n support
+ */
+export const streetAddressValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .min(5, { message: 'Validations.minLength' })
+  .max(200, { message: 'Validations.maxLength' });
+
+/**
+ * City validation with i18n support
+ */
+export const cityValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .min(2, { message: 'Validations.minLength' })
+  .max(100, { message: 'Validations.maxLength' });
+
+/**
+ * Postal code validation with i18n support
+ */
+export const postalCodeValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .regex(/^[\dA-Z\s\-]+$/i, {
+    message: 'Validations.invalidFormat',
+  });
+
+/**
+ * Country code validation with i18n support
+ */
+export const countryCodeValidationI18n = z
+  .string()
+  .min(1, { message: 'Validations.required' })
+  .length(2, { message: 'Validations.invalidFormat' });
+
+/**
+ * State/Province validation with i18n support
+ */
+export const stateProvinceValidationI18n = z
+  .string()
+  .max(100, { message: 'Validations.maxLength' })
+  .optional();
+
+/**
+ * Gender validation with i18n support (optional)
+ */
+export const genderValidationI18n = z
+  .enum(['male', 'female', 'diverse'], {
+    message: 'Validations.required',
+  })
+  .optional();
+
+/**
+ * Birthday validation with i18n support (optional)
+ */
+export const birthdayValidationI18n = z
+  .string()
+  .refine(
+    val => {
+      if (!val) {
+        return true;
+      }
+      const date = new Date(val);
+      if (Number.isNaN(date.getTime())) {
+        return false;
+      }
+
+      const today = new Date();
+      const minDate = new Date();
+      minDate.setFullYear(today.getFullYear() - 120);
+
+      return date >= minDate && date <= today;
+    },
+    { message: 'Validations.invalidDate' },
+  )
+  .optional();
+
+// ==================== Utility Functions ====================
+
+/**
+ * Makes any validation optional (allows empty string or undefined)
+ */
+export function optional<T extends z.ZodTypeAny>(schema: T) {
+  return schema.optional().or(z.literal(''));
+}
+
+/**
+ * Type guard for file validation errors
+ */
+const isFileValidationError = (value: unknown): value is FileValidationError => {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'isValidationError' in value &&
+    value.isValidationError === true
+  );
+};
+
+/**
+ * Valid file input types for validation
+ */
+type FileInput = File | string | FileValidationError | null | undefined;
+
+/**
+ * Creates a file validation schema with i18n support
+ * @param required - Whether the file is required
+ */
+export const createFileValidation = (required = false) =>
+  z.custom<FileInput>().superRefine((value, ctx) => {
+    // Handle validation error objects
+    if (isFileValidationError(value)) {
+      ctx.addIssue({
+        code: 'custom',
+        message: value.errorMessage,
+      });
+      return;
+    }
+
+    // If required, reject null/undefined/empty string
+    if (required && !value) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Validations.File.required',
+      });
+      return;
+    }
+
+    // If value is a string (URL), it's valid - this happens after upload
+    if (typeof value === 'string' && value.length > 0) {
+      return;
+    }
+
+    // If value exists but is not a File instance or valid string, reject it
+    if (value && !(value instanceof File) && typeof value !== 'string') {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Validations.File.invalidType',
+      });
+    }
+  });
+
+/**
+ * Password requirement type for validation feedback
+ */
+type PasswordRequirement = {
+  text: string;
+  isValid: boolean;
+};
+
+/**
+ * Validates password requirements and returns validation results
+ * Used for real-time password strength feedback
+ */
+export const validatePasswordRequirements = (
+  password: string,
+  t: ReturnType<typeof useTranslations>,
+): PasswordRequirement[] => {
+  return [
+    { text: t('minLength'), isValid: password.length >= 8 },
+    { text: t('maxLength'), isValid: password.length > 0 && password.length <= 50 },
+    { text: t('uppercase'), isValid: /[A-Z]/.test(password) },
+    { text: t('number'), isValid: /\d/.test(password) },
+    { text: t('specialChar'), isValid: /[@#$%]/.test(password) },
+    { text: t('englishOnly'), isValid: password.length > 0 && /^[a-z0-9@#$%]*$/i.test(password) },
+  ];
+};

package/templates/boilerplate/validations/zodErrorMap.ts

@@ -0,0 +1,101 @@
+import type { z } from 'zod';
+
+/**
+ * Translation function type - simplified to accept any params
+ */
+type TranslationFn = (key: string, params?: Record<string, unknown>) => string;
+
+/**
+ * Custom Zod error metadata for i18n
+ */
+export type ZodErrorMetadata = {
+  translationKey?: string;
+  params?: Record<string, string | number>;
+};
+
+/**
+ * Extract parameter types from ZodErrorMap
+ */
+type ZodErrorMapParams = Parameters<z.ZodErrorMap>;
+type ZodIssueType = ZodErrorMapParams[0];
+
+/**
+ * Extended issue type with all possible properties and custom metadata
+ */
+type ZodIssueWithMetadata = {
+  code: string;
+  path: (string | number)[];
+  message?: string;
+  received?: string;
+  expected?: string;
+  validation?: string;
+  minimum?: number;
+  maximum?: number;
+  type?: string;
+  params?: ZodErrorMetadata;
+};
+
+/**
+ * Creates a custom Zod error map for i18n translation
+ * This replaces the pipe format with a clean, type-safe approach
+ */
+export const createZodErrorMap = (t: TranslationFn): z.ZodErrorMap => {
+  return ((issue: ZodIssueType) => {
+    const typedIssue = issue as ZodIssueWithMetadata;
+    // Get custom metadata if provided
+    const metadata = typedIssue.params;
+    const translationKey = metadata?.translationKey;
+    const params = metadata?.params;
+
+    // If custom translation key is provided, use it
+    if (translationKey) {
+      return {
+        message: params ? t(translationKey, params) : t(translationKey),
+      };
+    }
+
+    // Handle different Zod issue types with default translations
+    switch (typedIssue.code) {
+      case 'invalid_type':
+        if (typedIssue.received === 'undefined' || typedIssue.received === 'null') {
+          return { message: t('Validations.required') };
+        }
+        return { message: t('Validations.invalidFormat') };
+
+      case 'invalid_string':
+        if (typedIssue.validation === 'email') {
+          return { message: t('Validations.email') };
+        }
+        if (typedIssue.validation === 'regex') {
+          return { message: t('Validations.invalidFormat') };
+        }
+        return { message: t('Validations.invalidFormat') };
+
+      case 'too_small':
+        if (typedIssue.type === 'string') {
+          if (typedIssue.minimum === 1) {
+            return { message: t('Validations.required') };
+          }
+          return {
+            message: t('Validations.minLength', { min: typedIssue.minimum as number }),
+          };
+        }
+        return { message: t('Validations.invalidFormat') };
+
+      case 'too_big':
+        if (typedIssue.type === 'string') {
+          return {
+            message: t('Validations.maxLength', { max: typedIssue.maximum as number }),
+          };
+        }
+        return { message: t('Validations.invalidFormat') };
+
+      case 'custom':
+        // For custom validations, the message is already set
+        return { message: typedIssue.message ?? t('Validations.invalidFormat') };
+
+      default:
+        return { message: t('Validations.invalidFormat') };
+    }
+  }) as z.ZodErrorMap;
+};

package/templates/configs/.env.example

@@ -0,0 +1,8 @@
+# Public Site URL
+NEXT_PUBLIC_API_URL=
+
+# Sentry Token
+SENTRY_AUTH_TOKEN=
+
+# Node Environment
+NODE_ENV=development

package/templates/configs/.prettierignore

@@ -0,0 +1,23 @@
+# Dependencies
+node_modules
+.pnp
+.pnp.js
+
+# Build outputs
+.next
+out
+dist
+build
+
+# Logs
+*.log
+
+# Package manager
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+
+# Ignore markdown and YAML files (if you want ESLint to handle them)
+*.md
+*.yml
+*.yaml

package/templates/configs/.prettierrc.cjs

@@ -0,0 +1,26 @@
+module.exports = {
+  printWidth: 100,
+  singleQuote: true,
+  semi: true,
+  trailingComma: 'all',
+  tabWidth: 2,
+  useTabs: false,
+  arrowParens: 'avoid',
+  plugins: ['prettier-plugin-tailwindcss'],
+  overrides: [
+    {
+      files: 'src/components/icons/**/*.{ts,tsx}',
+      options: {
+        plugins: [],
+        printWidth: 100,
+      },
+    },
+    {
+      // Disable Tailwind plugin for JS/TS/JSX/TSX (ESLint handles it)
+      files: '**/*.{js,jsx,ts,tsx}',
+      options: {
+        plugins: [],
+      },
+    },
+  ],
+};

package/templates/configs/.prettierrc.icons.cjs

@@ -0,0 +1,11 @@
+module.exports = {
+  printWidth: 80,
+  singleQuote: true,
+  semi: true,
+  trailingComma: 'all',
+  tabWidth: 2,
+  useTabs: false,
+  arrowParens: 'avoid',
+  singleAttributePerLine: true,
+  plugins: [],
+};

package/templates/configs/Dockerfile

@@ -0,0 +1,6 @@
+FROM node:20-bullseye AS base
+WORKDIR /app
+
+RUN npm install -g pnpm
+
+COPY package.json pnpm-lock.yaml ./ .npmrc ./

package/templates/configs/commitlint.config.ts

@@ -0,0 +1,8 @@
+import type { UserConfig } from '@commitlint/types';
+
+const Configuration: UserConfig = {
+  extends: ['@commitlint/config-conventional'],
+  ignores: [message => message.startsWith('chore: bump')], // Ignore dependabot commits
+};
+
+export default Configuration;