metabinaries 1.0.0

package/src/templates/configs.js

@@ -0,0 +1,303 @@
+export const configTemplates = {
+  '.gitattributes': `# Auto detect text files and perform LF normalization
+* text=auto
+
+# Force Unix line endings for shell scripts
+*.sh text eol=lf
+.husky/* text eol=lf
+
+# Force Windows line endings for batch files
+*.bat text eol=crlf
+
+# Binary files
+*.png binary
+*.jpg binary
+*.ico binary
+*.gif binary
+*.woff binary
+*.woff2 binary
+`,
+
+  '.gitignore': `# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts`,
+
+  '.env': `NEXT_PUBLIC_API_URL=https://api.example.com
+NEXT_PUBLIC_APP_URL=https://app.example.com
+NEXT_PUBLIC_SITE_URL=https://example.com
+NEXT_PUBLIC_DEFAULT_LOCALE=en`,
+
+  '.env.local': `NEXT_PUBLIC_API_URL=http://localhost:3000/api
+NEXT_PUBLIC_APP_URL=http://localhost:3000
+NEXT_PUBLIC_SITE_URL=http://localhost:3000
+NEXT_PUBLIC_DEFAULT_LOCALE=en`,
+
+  '.env.example': `NEXT_PUBLIC_API_URL=
+NEXT_PUBLIC_APP_URL=
+NEXT_PUBLIC_SITE_URL=
+NEXT_PUBLIC_DEFAULT_LOCALE=en`,
+
+  'api.yml': projectName => `openapi: 3.0.0
+info:
+  title: ${projectName} API
+  version: 1.0.0
+paths: {}`,
+
+  '.versionrc.json': `{
+  "types": [
+    {"type": "feat", "section": "Features"},
+    {"type": "fix", "section": "Bug Fixes"}
+  ]
+}`,
+
+  'components.json': `{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "default",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "app/[locale]/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils"
+  }
+}`,
+
+  'eslint.config.mjs': `export default [];`,
+
+  'next.config.ts': `import type { NextConfig } from "next";
+import createNextIntlPlugin from "next-intl/plugin";
+
+const withNextIntl = createNextIntlPlugin();
+
+const nextConfig: NextConfig = {
+
+  async headers() {
+    return [
+      {
+        source: "/api/(.*)",
+        headers: [
+          { key: "Access-Control-Allow-Credentials", value: "true" },
+          { key: "Access-Control-Allow-Origin", value: "*" }, // Recommended: Change to specific domain in production
+          {
+            key: "Access-Control-Allow-Methods",
+            value: "GET, POST, PUT, DELETE, OPTIONS, PATCH",
+          },
+          {
+            key: "Access-Control-Allow-Headers",
+            value: "Content-Type, Authorization, x-user-id, Accept",
+          },
+        ],
+      },
+      {
+        source: "/(.*)",
+        headers: [
+          { key: "X-Frame-Options", value: "DENY" },
+          { key: "X-Content-Type-Options", value: "nosniff" },
+          { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" },
+          { key: "Permissions-Policy", value: "camera=(), microphone=(), geolocation=()" },
+          { key: "Strict-Transport-Security", value: "max-age=31536000; includeSubDomains; preload" },
+          { key: "X-XSS-Protection", value: "1; mode=block" },
+        ],
+      },
+    ];
+  },
+  
+  allowedDevOrigins: [
+    "http://localhost:3000",
+    ...(process.env.NEXT_PUBLIC_API_URL
+      ? [process.env.NEXT_PUBLIC_API_URL]
+      : []),
+    "https://api-dev.smartbinaries.com/",
+  ],
+
+  images: {
+    remotePatterns: [
+      {
+        protocol: "https",
+        hostname: "**",
+        port: "",
+        pathname: "/**",
+      },
+      {
+        protocol: "http",
+        hostname: "**",
+        port: "",
+        pathname: "/**",
+      },
+    ],
+    unoptimized: true,
+    formats: ["image/avif", "image/webp"],
+  },
+};
+
+export default withNextIntl(nextConfig);`,
+
+  'postcss.config.mjs': `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;`,
+
+  'tailwind.config.ts': `import type { Config } from "tailwindcss";
+
+const config: Config = {
+    darkMode: "class",
+    content: [
+    "./pages/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+  	extend: {
+  		colors: {
+  			background: 'hsl(var(--background))',
+  			foreground: 'hsl(var(--foreground))',
+  			card: {
+  				DEFAULT: 'hsl(var(--card))',
+  				foreground: 'hsl(var(--card-foreground))'
+  			},
+  			popover: {
+  				DEFAULT: 'hsl(var(--popover))',
+  				foreground: 'hsl(var(--popover-foreground))'
+  			},
+  			primary: {
+  				DEFAULT: 'hsl(var(--primary))',
+  				foreground: 'hsl(var(--primary-foreground))'
+  			},
+  			secondary: {
+  				DEFAULT: 'hsl(var(--secondary))',
+  				foreground: 'hsl(var(--secondary-foreground))'
+  			},
+  			muted: {
+  				DEFAULT: 'hsl(var(--muted))',
+  				foreground: 'hsl(var(--muted-foreground))'
+  			},
+  			accent: {
+  				DEFAULT: 'hsl(var(--accent))',
+  				foreground: 'hsl(var(--accent-foreground))'
+  			},
+  			destructive: {
+  				DEFAULT: 'hsl(var(--destructive))',
+  				foreground: 'hsl(var(--destructive-foreground))'
+  			},
+  			border: 'hsl(var(--border))',
+  			input: 'hsl(var(--input))',
+  			ring: 'hsl(var(--ring))',
+  			chart: {
+  				'1': 'hsl(var(--chart-1))',
+  				'2': 'hsl(var(--chart-2))',
+  				'3': 'hsl(var(--chart-3))',
+  				'4': 'hsl(var(--chart-4))',
+  				'5': 'hsl(var(--chart-5))'
+  			}
+  		},
+  		borderRadius: {
+  			lg: 'var(--radius)',
+  			md: 'calc(var(--radius) - 2px)',
+  			sm: 'calc(var(--radius) - 4px)'
+  		}
+  	}
+  },
+  plugins: [require("tailwindcss-animate")],
+};
+export default config;`,
+
+  'tsconfig.json': `{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts",
+    "app/[locale]/(auth)/layout.tsx"
+  ],
+  "exclude": ["node_modules"]
+}`,
+  'i18n.ts': `import { getRequestConfig } from 'next-intl/server';
+import { notFound } from 'next/navigation';
+import { routing } from './i18n/routing';
+
+export default getRequestConfig(async ({ locale }) => {
+  // Validate that the incoming \`locale\` parameter is valid
+  if (!locale || !routing.locales.includes(locale as any)) notFound();
+
+  return {
+    locale,
+    messages: (await import(\`./messages/\${locale}.json\`)).default,
+  };
+});`,
+  'messages/en.json': `{
+  "HomePage": {
+    "title": "Welcome to MetaBinaries",
+    "description": "Your CRM-style workspace is ready."
+  }
+}`,
+  'messages/ar.json': `{
+  "HomePage": {
+    "title": "مرحباً بك في ميتابيناريز",
+    "description": "بيئة عمل CRM الخاصة بك جاهزة."
+  }
+}`,
+};

package/src/templates/core.js

@@ -0,0 +1,328 @@
+export const coreTemplates = {
+  'lib/utils.ts': `import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}`,
+
+  'hooks/use-mobile.tsx': `import * as React from 'react';
+
+const MOBILE_BREAKPOINT = 768;
+
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(
+    undefined
+  );
+
+  React.useEffect(() => {
+    const mql = window.matchMedia(\`(max-width: \${MOBILE_BREAKPOINT - 1}px)\`);
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    };
+    mql.addEventListener('change', onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener('change', onChange);
+  }, []);
+
+  return !!isMobile;
+}`,
+
+  'hooks/use-mobile.ts': `export function useIsMobile() { return false; }`,
+
+  'lib/rate-limit.ts': `import { NextRequest, NextResponse } from 'next/server';
+
+// Rate limiting configuration
+const RATE_LIMIT_CONFIG = {
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  maxRequests: 5, // Maximum 5 requests per window
+  message: 'Too many contact form submissions, please try again later.',
+};
+
+// Store for rate limiting (in production, use Redis or similar)
+const rateLimitStore = new Map<string, { count: number; resetTime: number }>();
+
+export function rateLimitMiddleware(request: NextRequest) {
+  const ip =
+    request.headers.get('x-forwarded-for') ||
+    request.headers.get('x-real-ip') ||
+    request.headers.get('cf-connecting-ip') ||
+    'unknown';
+  const now = Date.now();
+  const windowMs = RATE_LIMIT_CONFIG.windowMs;
+
+  // Clean up expired entries
+  for (const [key, value] of rateLimitStore.entries()) {
+    if (now > value.resetTime) {
+      rateLimitStore.delete(key);
+    }
+  }
+
+  const current = rateLimitStore.get(ip);
+
+  if (!current) {
+    // First request from this IP
+    rateLimitStore.set(ip, {
+      count: 1,
+      resetTime: now + windowMs,
+    });
+    return null; // No rate limit exceeded
+  }
+
+  if (now > current.resetTime) {
+    // Window has expired, reset
+    rateLimitStore.set(ip, {
+      count: 1,
+      resetTime: now + windowMs,
+    });
+    return null; // No rate limit exceeded
+  }
+
+  if (current.count >= RATE_LIMIT_CONFIG.maxRequests) {
+    // Rate limit exceeded
+    return NextResponse.json(
+      {
+        success: false,
+        error: RATE_LIMIT_CONFIG.message,
+        retryAfter: Math.ceil((current.resetTime - now) / 1000),
+      },
+      { status: 429 }
+    );
+  }
+
+  // Increment count
+  current.count++;
+  rateLimitStore.set(ip, current);
+
+  return null; // No rate limit exceeded
+}
+
+// Alternative implementation using a more sophisticated approach
+export class RateLimiter {
+  private store = new Map<string, { count: number; resetTime: number }>();
+
+  constructor(
+    private windowMs: number = 15 * 60 * 1000, // 15 minutes
+    private maxRequests: number = 5
+  ) {}
+
+  isAllowed(identifier: string): { allowed: boolean; retryAfter?: number } {
+    const now = Date.now();
+
+    // Clean up expired entries
+    this.cleanup();
+
+    const current = this.store.get(identifier);
+
+    if (!current) {
+      this.store.set(identifier, {
+        count: 1,
+        resetTime: now + this.windowMs,
+      });
+      return { allowed: true };
+    }
+
+    if (now > current.resetTime) {
+      // Window has expired, reset
+      this.store.set(identifier, {
+        count: 1,
+        resetTime: now + this.windowMs,
+      });
+      return { allowed: true };
+    }
+
+    if (current.count >= this.maxRequests) {
+      return {
+        allowed: false,
+        retryAfter: Math.ceil((current.resetTime - now) / 1000),
+      };
+    }
+
+    // Increment count
+    current.count++;
+    this.store.set(identifier, current);
+
+    return { allowed: true };
+  }
+
+  private cleanup() {
+    const now = Date.now();
+    for (const [key, value] of this.store.entries()) {
+      if (now > value.resetTime) {
+        this.store.delete(key);
+      }
+    }
+  }
+
+  // Get remaining requests for an identifier
+  getRemainingRequests(identifier: string): number {
+    const current = this.store.get(identifier);
+    if (!current) return this.maxRequests;
+
+    const now = Date.now();
+    if (now > current.resetTime) return this.maxRequests;
+
+    return Math.max(0, this.maxRequests - current.count);
+  }
+
+  // Get reset time for an identifier
+  getResetTime(identifier: string): number | null {
+    const current = this.store.get(identifier);
+    if (!current) return null;
+
+    const now = Date.now();
+    if (now > current.resetTime) return null;
+
+    return current.resetTime;
+  }
+}
+
+// Create a global rate limiter instance
+export const contactFormRateLimiter = new RateLimiter(
+  15 * 60 * 1000, // 15 minutes
+  5 // 5 requests per window
+);`,
+
+  'lib/features/NAME/NAME.api.ts': `export const nameApi = {};`,
+  'lib/features/NAME/NAME.service.ts': `export const nameService = {};`,
+  'lib/features/NAME/NAME.slice.ts': `import { createSlice } from '@reduxjs/toolkit';
+export const nameSlice = createSlice({ name: 'name', initialState: {}, reducers: {} });
+export default nameSlice.reducer;`,
+  'lib/features/NAME/NAME.types.ts': `export interface NameType {}`,
+  'lib/features/NAME/NAME.utils.ts': `export const nameUtils = {};`,
+  'lib/features/NAME/useNAME.ts': `export const useName = () => ({});`,
+
+  'lib/shared/store.ts': `import { configureStore } from '@reduxjs/toolkit';
+export const store = configureStore({ reducer: {} });`,
+
+  'lib/shared/axios.ts': `import axios from 'axios';
+
+const instance = axios.create({
+  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  timeout: 10000, // Security: Add timeout to prevent hanging requests
+});
+
+// Request Interceptor: Add Authorization header
+instance.interceptors.request.use(
+  (config) => {
+    // Security: Ensure token is retrieved safely
+    const token = typeof window !== 'undefined' ? localStorage.getItem('token') : null;
+    if (token) {
+      config.headers.Authorization = \`Bearer \${token}\`;
+    }
+    return config;
+  },
+  (error) => Promise.reject(error)
+);
+
+// Response Interceptor: Handle global errors (e.g., 401)
+instance.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    if (error.response?.status === 401) {
+      // Security: Clear sensible data on unauthorized access
+      if (typeof window !== 'undefined') {
+        localStorage.removeItem('token');
+        const locale = window.location.pathname.split('/')[1] || 'en';
+        window.location.href = \`/\${locale}/login\`;
+      }
+    }
+    
+    // Security: Sanitize error responses before logging/showing to users
+    const sanitizedError = {
+      message: error.response?.data?.message || error.message || 'An unexpected error occurred',
+      status: error.response?.status,
+    };
+    
+    return Promise.reject(sanitizedError);
+  }
+);
+
+export default instance;`,
+
+  'lib/shared/utils/validation/common-rules.ts': `import { z } from 'zod';
+export const commonRules = { email: z.string().email() };`,
+
+  'lib/shared/utils/validation/NAME.validation.ts': `import { z } from 'zod';
+export const nameValidation = z.object({});`,
+
+  'i18n/routing.ts': `import { defineRouting } from 'next-intl/routing';
+
+export const routing = defineRouting({
+  // A list of all locales that are supported
+  locales: ['en', 'ar'],
+
+  // Used when no locale matches
+  defaultLocale:
+    (process.env.NEXT_PUBLIC_DEFAULT_LOCALE as 'en' | 'ar') || 'en',
+  localePrefix: 'always',
+});`,
+
+  'i18n/navigation.ts': `import { createNavigation } from 'next-intl/navigation';
+import { routing } from './routing';
+
+// Lightweight wrappers around Next.js' navigation
+// APIs that consider the routing configuration
+export const { Link, redirect, usePathname, useRouter, getPathname } =
+  createNavigation(routing);`,
+
+  'i18n/request.ts': `import { getRequestConfig } from 'next-intl/server';
+import { hasLocale } from 'next-intl';
+import { routing } from './routing';
+
+export default getRequestConfig(async ({ requestLocale }) => {
+  // Typically corresponds to the \`[locale]\` segment
+  const requested = await requestLocale;
+  let locale = hasLocale(routing.locales, requested)
+    ? requested
+    : routing.defaultLocale;
+
+  // Safety check: ensure locale is never undefined or empty
+  if (!locale || !hasLocale(routing.locales, locale)) {
+    locale = 'en'; // Fallback to 'en' as the ultimate default
+  }
+
+  return {
+    locale,
+    messages: (await import(\`@/messages/\${locale}.json\`)).default,
+  };
+});`,
+
+  'middleware.ts': `import createMiddleware from 'next-intl/middleware';
+import { routing } from './i18n/routing';
+
+export default createMiddleware(routing);
+
+export const config = {
+  matcher: ['/', '/(ar|en)/:path*']
+};`,
+
+  'lib/features/notifications/NotificationContext.tsx': `'use client';
+
+import React, { createContext, useContext, useState, ReactNode } from 'react';
+
+interface NotificationContextType {
+  // Add notification state and methods here
+}
+
+const NotificationContext = createContext<NotificationContextType | undefined>(undefined);
+
+export function NotificationProvider({ children }: { children: ReactNode }) {
+  return (
+    <NotificationContext.Provider value={{}}>
+      {children}
+    </NotificationContext.Provider>
+  );
+}
+
+export function useNotifications() {
+  const context = useContext(NotificationContext);
+  if (context === undefined) {
+    throw new Error('useNotifications must be used within a NotificationProvider');
+  }
+  return context;
+}`,
+};

package/src/templates/folder-structure.js

@@ -0,0 +1,21 @@
+export const folderStructure = [
+  '.husky',
+  '.husky/_',
+  'app/[locale]/(auth)/forgot-password',
+  'app/[locale]/(auth)/login',
+  'app/[locale]/(auth)/sign-up',
+  'app/[locale]/(auth)/_components',
+  'app/[locale]/(workspace)/(home)/_components',
+  'app/[locale]/(workspace)/_Components',
+  'components/layout',
+  'components/shared',
+  'components/ui',
+  'docs',
+  'hooks',
+  'i18n',
+  'lib/features/NAME',
+  'lib/shared/utils/validation',
+  'messages',
+  'public/images',
+  'public/icons',
+];