create-blitzpack 0.1.0

package/template/packages/utils/src/__tests__/utils.test.ts

@@ -0,0 +1,223 @@
+import { groupBy, unique } from '@repo/packages-utils/array';
+import { sleep } from '@repo/packages-utils/async';
+import {
+  formatDate,
+  formatDateTime,
+  getRelativeTime,
+} from '@repo/packages-utils/date';
+import { clamp, formatBytes } from '@repo/packages-utils/number';
+import { slugify, truncate } from '@repo/packages-utils/string';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+describe('slugify', () => {
+  it('should convert text to slug format', () => {
+    expect(slugify('Hello World')).toBe('hello-world');
+    expect(slugify('TypeScript is Great!')).toBe('typescript-is-great');
+  });
+
+  it('should handle special characters', () => {
+    expect(slugify('React & Vue.js')).toBe('react-vuejs');
+    expect(slugify('C++ Programming')).toBe('c-programming');
+  });
+
+  it('should handle multiple spaces and trim', () => {
+    expect(slugify('  too   many    spaces  ')).toBe('too-many-spaces');
+  });
+
+  it('should handle underscores', () => {
+    expect(slugify('snake_case_text')).toBe('snake-case-text');
+  });
+});
+
+describe('truncate', () => {
+  it('should truncate text longer than maxLength', () => {
+    expect(truncate('This is a long text', 10)).toBe('This is...');
+  });
+
+  it('should not truncate text shorter than maxLength', () => {
+    expect(truncate('Short', 10)).toBe('Short');
+  });
+
+  it('should return text as-is when exactly maxLength', () => {
+    expect(truncate('Exactly10!', 10)).toBe('Exactly10!');
+  });
+});
+
+describe('formatDate', () => {
+  it('should format Date object to YYYY-MM-DD', () => {
+    const date = new Date('2024-01-15T10:30:00Z');
+    expect(formatDate(date)).toBe('2024-01-15');
+  });
+
+  it('should format ISO string to YYYY-MM-DD', () => {
+    expect(formatDate('2024-01-15T10:30:00Z')).toBe('2024-01-15');
+  });
+});
+
+describe('formatDateTime', () => {
+  it('should format Date object to localized string', () => {
+    const date = new Date('2024-01-15T10:30:00Z');
+    const formatted = formatDateTime(date);
+    expect(formatted).toContain('Jan');
+    expect(formatted).toContain('15');
+    expect(formatted).toContain('2024');
+  });
+
+  it('should format ISO string to localized string', () => {
+    const formatted = formatDateTime('2024-01-15T10:30:00Z');
+    expect(formatted).toContain('Jan');
+    expect(formatted).toContain('15');
+    expect(formatted).toContain('2024');
+  });
+});
+
+describe('getRelativeTime', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  it('should return "just now" for recent dates', () => {
+    const now = new Date();
+    vi.setSystemTime(now);
+    const recentDate = new Date(now.getTime() - 30000);
+    expect(getRelativeTime(recentDate)).toBe('just now');
+  });
+
+  it('should return minutes ago', () => {
+    const now = new Date();
+    vi.setSystemTime(now);
+    const pastDate = new Date(now.getTime() - 5 * 60 * 1000);
+    expect(getRelativeTime(pastDate)).toBe('5 minutes ago');
+  });
+
+  it('should return hours ago', () => {
+    const now = new Date();
+    vi.setSystemTime(now);
+    const pastDate = new Date(now.getTime() - 3 * 60 * 60 * 1000);
+    expect(getRelativeTime(pastDate)).toBe('3 hours ago');
+  });
+
+  it('should return days ago', () => {
+    const now = new Date();
+    vi.setSystemTime(now);
+    const pastDate = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000);
+    expect(getRelativeTime(pastDate)).toBe('2 days ago');
+  });
+
+  it('should return formatted date for old dates', () => {
+    const now = new Date();
+    vi.setSystemTime(now);
+    const oldDate = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+    const result = getRelativeTime(oldDate);
+    expect(result).toMatch(/\d{4}-\d{2}-\d{2}/);
+  });
+});
+
+describe('sleep', () => {
+  it('should resolve after specified milliseconds', async () => {
+    vi.useFakeTimers();
+    const promise = sleep(1000);
+    vi.advanceTimersByTime(1000);
+    await expect(promise).resolves.toBeUndefined();
+    vi.useRealTimers();
+  });
+});
+
+describe('formatBytes', () => {
+  it('should format zero bytes', () => {
+    expect(formatBytes(0)).toBe('0 Bytes');
+  });
+
+  it('should format bytes', () => {
+    expect(formatBytes(500)).toBe('500 Bytes');
+  });
+
+  it('should format kilobytes', () => {
+    expect(formatBytes(1024)).toBe('1 KB');
+    expect(formatBytes(1536)).toBe('1.5 KB');
+  });
+
+  it('should format megabytes', () => {
+    expect(formatBytes(1048576)).toBe('1 MB');
+    expect(formatBytes(5242880)).toBe('5 MB');
+  });
+
+  it('should format gigabytes', () => {
+    expect(formatBytes(1073741824)).toBe('1 GB');
+  });
+
+  it('should respect decimals parameter', () => {
+    expect(formatBytes(1536, 0)).toBe('2 KB');
+    expect(formatBytes(1536, 3)).toBe('1.5 KB');
+  });
+});
+
+describe('clamp', () => {
+  it('should clamp value within range', () => {
+    expect(clamp(5, 0, 10)).toBe(5);
+  });
+
+  it('should clamp to minimum', () => {
+    expect(clamp(-5, 0, 10)).toBe(0);
+  });
+
+  it('should clamp to maximum', () => {
+    expect(clamp(15, 0, 10)).toBe(10);
+  });
+
+  it('should handle negative ranges', () => {
+    expect(clamp(-15, -10, -5)).toBe(-10);
+    expect(clamp(-3, -10, -5)).toBe(-5);
+  });
+});
+
+describe('unique', () => {
+  it('should remove duplicates from array', () => {
+    expect(unique([1, 2, 2, 3, 3, 3, 4])).toEqual([1, 2, 3, 4]);
+  });
+
+  it('should work with strings', () => {
+    expect(unique(['a', 'b', 'a', 'c', 'b'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should return empty array for empty input', () => {
+    expect(unique([])).toEqual([]);
+  });
+
+  it('should preserve single item arrays', () => {
+    expect(unique([1])).toEqual([1]);
+  });
+});
+
+describe('groupBy', () => {
+  it('should group objects by key function', () => {
+    const items = [
+      { name: 'Alice', age: 25 },
+      { name: 'Bob', age: 30 },
+      { name: 'Charlie', age: 25 },
+    ];
+
+    const grouped = groupBy(items, (item) => item.age);
+    expect(grouped[25]).toHaveLength(2);
+    expect(grouped[30]).toHaveLength(1);
+    expect(grouped[25][0].name).toBe('Alice');
+    expect(grouped[25][1].name).toBe('Charlie');
+  });
+
+  it('should work with string keys', () => {
+    const items = [
+      { type: 'fruit', name: 'apple' },
+      { type: 'vegetable', name: 'carrot' },
+      { type: 'fruit', name: 'banana' },
+    ];
+
+    const grouped = groupBy(items, (item) => item.type);
+    expect(grouped.fruit).toHaveLength(2);
+    expect(grouped.vegetable).toHaveLength(1);
+  });
+
+  it('should handle empty array', () => {
+    const grouped = groupBy([], (item: { id: number }) => item.id);
+    expect(grouped).toEqual({});
+  });
+});

package/template/packages/utils/src/array.ts

@@ -0,0 +1,18 @@
+export function unique<T>(array: T[]): T[] {
+  return [...new Set(array)];
+}
+
+export function groupBy<T, K extends string | number | symbol>(
+  array: T[],
+  keyFn: (item: T) => K
+): Record<K, T[]> {
+  return array.reduce(
+    (acc, item) => {
+      const key = keyFn(item);
+      if (!acc[key]) acc[key] = [];
+      acc[key].push(item);
+      return acc;
+    },
+    {} as Record<K, T[]>
+  );
+}

package/template/packages/utils/src/async.ts

@@ -0,0 +1,3 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/template/packages/utils/src/date.ts

@@ -0,0 +1,77 @@
+export function formatDate(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toISOString().split('T')[0];
+}
+
+export function formatDateTime(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toLocaleString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
+
+export function formatShortDate(
+  date: Date | string,
+  includeYear = false
+): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toLocaleString('en-US', {
+    month: 'short',
+    day: 'numeric',
+    ...(includeYear && { year: 'numeric' }),
+  });
+}
+
+export function getRelativeTime(
+  date: Date | string,
+  options: { short?: boolean; alwaysShowTime?: boolean } = {}
+): string {
+  const { short = false, alwaysShowTime = false } = options;
+  const d = typeof date === 'string' ? new Date(date) : date;
+  const now = new Date();
+  const seconds = Math.floor((now.getTime() - d.getTime()) / 1000);
+
+  if (seconds < 60) {
+    return alwaysShowTime ? (short ? '1m ago' : '1 minute ago') : 'just now';
+  }
+
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return short ? `${minutes}m ago` : `${minutes} minutes ago`;
+  }
+
+  const hours = Math.floor(seconds / 3600);
+  if (hours < 24) {
+    return short ? `${hours}h ago` : `${hours} hours ago`;
+  }
+
+  const days = Math.floor(seconds / 86400);
+  if (days < 7) {
+    return short ? `${days}d ago` : `${days} days ago`;
+  }
+
+  const weeks = Math.floor(days / 7);
+  if (weeks < 4) {
+    return short ? `${weeks}w ago` : `${weeks} weeks ago`;
+  }
+
+  return formatDate(d);
+}
+
+export function formatTime(date: Date | string | number): string {
+  const d =
+    typeof date === 'number'
+      ? new Date(date)
+      : typeof date === 'string'
+        ? new Date(date)
+        : date;
+  return d.toLocaleTimeString(undefined, {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+}

package/template/packages/utils/src/errors.ts

@@ -0,0 +1,73 @@
+export class AppError extends Error {
+  readonly statusCode: number;
+  readonly code: string;
+  readonly details?: Record<string, unknown>;
+
+  constructor(
+    message: string,
+    statusCode: number,
+    code: string,
+    details?: Record<string, unknown>
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 400, 'VALIDATION_ERROR', details);
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(
+    message: string = 'Authentication required',
+    details?: Record<string, unknown>
+  ) {
+    super(message, 401, 'UNAUTHORIZED', details);
+  }
+}
+
+export class ForbiddenError extends AppError {
+  constructor(
+    message: string = 'Insufficient permissions',
+    details?: Record<string, unknown>
+  ) {
+    super(message, 403, 'FORBIDDEN', details);
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 404, 'NOT_FOUND', details);
+  }
+}
+
+export class ConflictError extends AppError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 409, 'CONFLICT', details);
+  }
+}
+
+export class RateLimitError extends AppError {
+  constructor(
+    message: string = 'Rate limit exceeded',
+    details?: Record<string, unknown>
+  ) {
+    super(message, 429, 'RATE_LIMIT_EXCEEDED', details);
+  }
+}
+
+export class InternalServerError extends AppError {
+  constructor(
+    message: string = 'Internal server error',
+    details?: Record<string, unknown>
+  ) {
+    super(message, 500, 'INTERNAL_ERROR', details);
+  }
+}

package/template/packages/utils/src/number.ts

@@ -0,0 +1,11 @@
+export function formatBytes(bytes: number, decimals = 2): string {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+export function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}

package/template/packages/utils/src/string.ts

@@ -0,0 +1,13 @@
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + '...';
+}

package/template/packages/utils/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/template/packages/utils/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig, mergeConfig } from 'vitest/config';
+
+import { sharedConfig } from '../../vitest.shared';
+
+export default mergeConfig(
+  sharedConfig,
+  defineConfig({
+    test: {
+      name: '@repo/packages-utils',
+      include: ['src/**/*.{test,spec}.{ts,tsx}'],
+      coverage: {
+        thresholds: {
+          lines: 70,
+          functions: 70,
+          branches: 60,
+          statements: 70,
+        },
+      },
+    },
+  })
+);

package/template/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+packages:
+  - 'apps/*'
+  - 'packages/*'
+  - 'create-blitzpack'

package/template/tsconfig.base.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "paths": {
+      "@repo/packages-types": ["packages/types/src/index.ts"],
+      "@repo/packages-types/*": ["packages/types/src/*"],
+      "@repo/packages-utils": ["packages/utils/src/index.ts"],
+      "@repo/packages-utils/*": ["packages/utils/src/*"]
+    }
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    "out",
+    "**/node_modules"
+  ]
+}

package/template/turbo.json

@@ -0,0 +1,133 @@
+{
+  "$schema": "https://turbo.build/schema.json",
+  "ui": "stream",
+  "globalDependencies": ["tsconfig.json", "turbo.json", "eslint.config.ts"],
+  "tasks": {
+    "build": {
+      "dependsOn": ["build:components"],
+      "outputs": ["dist/**", ".next/**", "build/**"],
+      "inputs": [
+        "src/**",
+        "prisma/**",
+        "package.json",
+        "tsconfig.json",
+        "next.config.ts",
+        "tailwind.config.ts"
+      ]
+    },
+    "build:components": {
+      "outputs": ["dist/**"],
+      "inputs": ["src/**/*.tsx", "src/**/*.ts", "tsconfig.json"]
+    },
+    "typecheck": {
+      "dependsOn": ["db:generate"],
+      "cache": true,
+      "inputs": ["src/**", "prisma/**", "tsconfig.json", "package.json"]
+    },
+    "dev": {
+      "dependsOn": ["db:generate"],
+      "cache": false,
+      "persistent": true,
+      "with": ["dev:components"]
+    },
+    "dev:components": {
+      "cache": false,
+      "persistent": true,
+      "outputs": ["dist/**"]
+    },
+    "db:generate": {
+      "cache": false
+    },
+    "lint": {
+      "dependsOn": [],
+      "inputs": ["src/**", "eslint.config.*", "package.json"],
+      "outputs": []
+    },
+    "lint:fix": {
+      "dependsOn": [],
+      "cache": false,
+      "inputs": ["src/**", "eslint.config.*", "package.json"]
+    },
+    "test": {
+      "dependsOn": [],
+      "inputs": [
+        "src/**",
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "vitest.config.ts",
+        "package.json"
+      ],
+      "outputs": ["coverage/**"]
+    },
+    "test:unit": {
+      "dependsOn": [],
+      "inputs": [
+        "src/**",
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "vitest.config.ts",
+        "package.json"
+      ],
+      "outputs": ["coverage/**"]
+    },
+    "test:integration": {
+      "dependsOn": [],
+      "inputs": [
+        "src/**",
+        "test/**",
+        "**/*.integration.spec.ts",
+        "vitest.config.ts",
+        "package.json"
+      ],
+      "outputs": ["coverage/**"]
+    },
+    "test:watch": {
+      "dependsOn": [],
+      "cache": false,
+      "persistent": true
+    },
+    "test:coverage": {
+      "dependsOn": [],
+      "outputs": ["coverage/**"],
+      "inputs": [
+        "src/**",
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "vitest.config.ts",
+        "package.json"
+      ]
+    },
+    "clean": {
+      "cache": false,
+      "outputs": []
+    },
+    "format": {
+      "cache": false,
+      "outputs": []
+    },
+    "format:check": {
+      "cache": true,
+      "outputs": []
+    },
+    "db:migrate": {
+      "cache": false,
+      "outputs": []
+    },
+    "db:push": {
+      "cache": false,
+      "outputs": []
+    },
+    "db:studio": {
+      "cache": false,
+      "persistent": true
+    },
+    "db:seed": {
+      "cache": false,
+      "outputs": []
+    },
+    "email:dev": {
+      "cache": false,
+      "persistent": true
+    }
+  }
+}

package/template/vitest.shared.ts

@@ -0,0 +1,26 @@
+import { defineConfig } from 'vitest/config';
+
+export const sharedConfig = defineConfig({
+  test: {
+    globals: true,
+    passWithNoTests: true,
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html', 'lcov'],
+      exclude: [
+        'node_modules/**',
+        'dist/**',
+        'build/**',
+        '.next/**',
+        '**/*.config.{js,ts,mjs,mts}',
+        '**/*.d.ts',
+        '**/index.ts',
+        '**/__tests__/**',
+        '**/test/**',
+        '**/*.spec.{ts,tsx}',
+        '**/*.test.{ts,tsx}',
+      ],
+    },
+    setupFiles: [],
+  },
+});

package/template/vitest.workspace.ts

@@ -0,0 +1,9 @@
+import { defineWorkspace } from 'vitest/config';
+
+export default defineWorkspace([
+  'shared/types/vitest.config.ts',
+  'shared/utils/vitest.config.ts',
+  'shared/config/vitest.config.ts',
+  'apps/api/vitest.config.ts',
+  'apps/web/vitest.config.ts',
+]);