init

packages/next-utils/src/env.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+export const mintelEnvSchema = {
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  NEXT_PUBLIC_BASE_URL: z.string().url(),
+  NEXT_PUBLIC_UMAMI_WEBSITE_ID: z.string().optional(),
+  NEXT_PUBLIC_UMAMI_SCRIPT_URL: z.string().url().default('https://analytics.infra.mintel.me/script.js'),
+  SENTRY_DSN: z.string().optional(),
+  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  MAIL_HOST: z.string().optional(),
+  MAIL_PORT: z.coerce.number().default(587),
+  MAIL_USERNAME: z.string().optional(),
+  MAIL_PASSWORD: z.string().optional(),
+  MAIL_FROM: z.string().optional(),
+  MAIL_RECIPIENTS: z.preprocess(
+    (val) => (typeof val === 'string' ? val.split(',').filter(Boolean) : val),
+    z.array(z.string()).default([])
+  ),
+};
+
+export function validateMintelEnv(schemaExtension = {}) {
+  const fullSchema = z.object({
+    ...mintelEnvSchema,
+    ...schemaExtension,
+  });
+
+  const result = fullSchema.safeParse(process.env);
+
+  if (!result.success) {
+    console.error('❌ Invalid environment variables:', result.error.flatten().fieldErrors);
+    throw new Error('Invalid environment variables');
+  }
+
+  return result.data;
+}

packages/next-utils/src/i18n.ts

@@ -0,0 +1,66 @@
+import createMiddleware from 'next-intl/middleware';
+import { getRequestConfig } from 'next-intl/server';
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export interface MintelI18nConfig {
+  locales: string[];
+  defaultLocale: string;
+  logRequests?: boolean;
+}
+
+export function createMintelMiddleware(config: MintelI18nConfig) {
+  const intlMiddleware = createMiddleware({
+    locales: config.locales,
+    defaultLocale: config.defaultLocale,
+  });
+
+  return function middleware(request: NextRequest) {
+    if (config.logRequests) {
+      const { method, url } = request;
+      console.log(`Incoming request: method=${method} url=${url}`);
+    }
+
+    try {
+      return intlMiddleware(request);
+    } catch (error) {
+      if (config.logRequests) {
+        console.error(`Request failed: ${request.method} ${request.url}`, error);
+      }
+      throw error;
+    }
+  };
+}
+
+export function createMintelI18nRequestConfig(
+  locales: string[],
+  defaultLocale: string,
+  importMessages: (locale: string) => Promise<any>
+) {
+  return getRequestConfig(async ({ requestLocale }) => {
+    let locale = await requestLocale;
+
+    if (!locale || !locales.includes(locale)) {
+      locale = defaultLocale;
+    }
+
+    return {
+      locale,
+      messages: (await importMessages(locale)).default,
+      onError(error: any) {
+        if (error.code === 'MISSING_MESSAGE') {
+          console.error(error.message);
+        } else {
+          console.error(error);
+        }
+      },
+      getMessageFallback({ namespace, key, error }: any) {
+        const path = [namespace, key].filter((part) => part != null).join('.');
+        if (error.code === 'MISSING_MESSAGE') {
+          return path;
+        }
+        return 'fallback';
+      }
+    };
+  });
+}

packages/next-utils/src/index.ts

@@ -0,0 +1,37 @@
+// Simple in-memory rate limiting
+const submissions: Record<string, number> = {};
+const RATE_LIMIT_WINDOW = 60 * 60 * 1000; // 1 hour
+const MAX_SUBMISSIONS_PER_WINDOW = 3;
+
+export async function rateLimit(identifier: string, windowMs = RATE_LIMIT_WINDOW, maxSubmissions = MAX_SUBMISSIONS_PER_WINDOW) {
+  const now = Date.now();
+
+  // Clean up old submissions
+  Object.keys(submissions).forEach((key) => {
+    if (now - submissions[key] > windowMs) {
+      delete submissions[key];
+    }
+  });
+
+  // Check if identifier has exceeded submission limit
+  const currentSubmissions = Object.values(submissions).filter(
+    (timestamp) => now - timestamp <= windowMs
+  );
+
+  if (currentSubmissions.length >= maxSubmissions) {
+    throw new Error("Too many submissions. Please try again later.");
+  }
+
+  // Record this submission
+  submissions[identifier] = now;
+}
+
+export const languages = ["en", "de"] as const;
+export type Lang = (typeof languages)[number];
+
+export function isValidLang(lang: string): lang is Lang {
+  return (languages as readonly string[]).includes(lang);
+}
+
+export * from "./i18n";
+export * from "./env";