create-blitzpack 0.1.0 → 0.1.2

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

@@ -1,223 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,77 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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

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

@@ -1,21 +0,0 @@
-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

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

package/template/tsconfig.base.json

@@ -1,32 +0,0 @@
-{
-  "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

@@ -1,133 +0,0 @@
-{
-  "$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

@@ -1,26 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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',
-]);