create-nuxt-base 1.2.0 → 2.0.0

package/nuxt-base-template/app/composables/use-tus-upload.ts

@@ -1,278 +0,0 @@
-import * as tus from 'tus-js-client';
-
-import type { UploadItem, UploadOptions, UploadProgress, UseTusUploadReturn } from '~/interfaces/upload.interface';
-
-export function useTusUpload(defaultOptions: UploadOptions = {}): UseTusUploadReturn {
-  const config = useRuntimeConfig();
-
-  // State
-  const uploadItems = ref<Map<string, UploadItem>>(new Map());
-  const tusUploads = ref<Map<string, tus.Upload>>(new Map());
-
-  // Default config
-  const defaultConfig: UploadOptions = {
-    autoStart: true,
-    chunkSize: 5 * 1024 * 1024, // 5MB chunks
-    endpoint: `${config.public.host}/files/upload`,
-    parallelUploads: 3,
-    retryDelays: [0, 1000, 3000, 5000, 10000],
-    ...defaultOptions,
-  };
-
-  // Computed
-  const uploads = computed(() => Array.from(uploadItems.value.values()));
-  const isUploading = computed(() => uploads.value.some((u) => u.status === 'uploading'));
-  const totalProgress = computed<UploadProgress>(() => {
-    const items = uploads.value;
-    if (items.length === 0) {
-      return { bytesTotal: 0, bytesUploaded: 0, percentage: 0, remainingTime: 0, speed: 0 };
-    }
-
-    const bytesUploaded = items.reduce((acc, i) => acc + i.progress.bytesUploaded, 0);
-    const bytesTotal = items.reduce((acc, i) => acc + i.progress.bytesTotal, 0);
-    const speed = items.reduce((acc, i) => acc + i.progress.speed, 0);
-
-    return {
-      bytesTotal,
-      bytesUploaded,
-      percentage: bytesTotal > 0 ? Math.round((bytesUploaded / bytesTotal) * 100) : 0,
-      remainingTime: speed > 0 ? Math.ceil((bytesTotal - bytesUploaded) / speed) : 0,
-      speed,
-    };
-  });
-
-  // Helper: Generate unique ID
-  function generateId(): string {
-    return `upload_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-  }
-
-  // Helper: Calculate speed with smoothing
-  function createSpeedTracker() {
-    let lastBytes = 0;
-    let lastTime = Date.now();
-    let smoothedSpeed = 0;
-
-    return (bytesUploaded: number): number => {
-      const now = Date.now();
-      const timeDiff = (now - lastTime) / 1000;
-      const bytesDiff = bytesUploaded - lastBytes;
-
-      if (timeDiff > 0) {
-        const currentSpeed = bytesDiff / timeDiff;
-        // Exponential moving average for smoother display
-        smoothedSpeed = smoothedSpeed === 0 ? currentSpeed : smoothedSpeed * 0.7 + currentSpeed * 0.3;
-      }
-
-      lastBytes = bytesUploaded;
-      lastTime = now;
-
-      return Math.round(smoothedSpeed);
-    };
-  }
-
-  // Update item in map (triggers reactivity)
-  function updateItem(id: string, updates: Partial<UploadItem>): void {
-    const item = uploadItems.value.get(id);
-    if (item) {
-      const newMap = new Map(uploadItems.value);
-      newMap.set(id, { ...item, ...updates });
-      uploadItems.value = newMap;
-    }
-  }
-
-  // Create TUS upload instance
-  function createTusUpload(item: UploadItem, options: UploadOptions): tus.Upload {
-    const speedTracker = createSpeedTracker();
-
-    return new tus.Upload(item.file, {
-      chunkSize: options.chunkSize || defaultConfig.chunkSize,
-      endpoint: options.endpoint || defaultConfig.endpoint,
-      headers: options.headers,
-      metadata: {
-        filename: item.file.name,
-        filetype: item.file.type,
-        ...options.metadata,
-        ...item.metadata,
-      },
-      onBeforeRequest: (req) => {
-        const xhr = req.getUnderlyingObject() as XMLHttpRequest;
-        xhr.withCredentials = true;
-      },
-      onError: (error) => {
-        updateItem(item.id, {
-          error: error.message,
-          status: 'error',
-        });
-        options.onError?.(uploadItems.value.get(item.id)!, error);
-      },
-
-      onProgress: (bytesUploaded, bytesTotal) => {
-        const speed = speedTracker(bytesUploaded);
-        const percentage = Math.round((bytesUploaded / bytesTotal) * 100);
-        const remainingTime = speed > 0 ? Math.ceil((bytesTotal - bytesUploaded) / speed) : 0;
-
-        updateItem(item.id, {
-          progress: { bytesTotal, bytesUploaded, percentage, remainingTime, speed },
-        });
-
-        options.onProgress?.(uploadItems.value.get(item.id)!);
-      },
-
-      onShouldRetry: (err) => {
-        const status = (err as { originalResponse?: { getStatus?: () => number } }).originalResponse?.getStatus?.();
-        // Don't retry on 4xx errors (except 429 Too Many Requests)
-        if (status && status >= 400 && status < 500 && status !== 429) {
-          return false;
-        }
-        return true;
-      },
-
-      onSuccess: () => {
-        const tusUpload = tusUploads.value.get(item.id);
-        const currentItem = uploadItems.value.get(item.id);
-        updateItem(item.id, {
-          completedAt: new Date(),
-          progress: { ...currentItem!.progress, percentage: 100 },
-          status: 'completed',
-          url: tusUpload?.url ?? undefined,
-        });
-        options.onSuccess?.(uploadItems.value.get(item.id)!);
-      },
-
-      retryDelays: options.retryDelays || defaultConfig.retryDelays,
-    });
-  }
-
-  // Actions
-  function addFiles(files: File | File[]): string[] {
-    const fileArray = Array.isArray(files) ? files : [files];
-    const ids: string[] = [];
-
-    for (const file of fileArray) {
-      const id = generateId();
-      const item: UploadItem = {
-        file,
-        id,
-        metadata: defaultConfig.metadata,
-        progress: { bytesTotal: file.size, bytesUploaded: 0, percentage: 0, remainingTime: 0, speed: 0 },
-        status: 'idle',
-      };
-
-      const newMap = new Map(uploadItems.value);
-      newMap.set(id, item);
-      uploadItems.value = newMap;
-
-      const tusUpload = createTusUpload(item, defaultConfig);
-      tusUploads.value.set(id, tusUpload);
-
-      ids.push(id);
-    }
-
-    if (defaultConfig.autoStart) {
-      startAll();
-    }
-
-    return ids;
-  }
-
-  function startUpload(id: string): void {
-    const item = uploadItems.value.get(id);
-    const tusUpload = tusUploads.value.get(id);
-
-    if (item && tusUpload && item.status !== 'uploading') {
-      updateItem(id, { startedAt: new Date(), status: 'uploading' });
-
-      // Check for previous uploads to resume
-      tusUpload.findPreviousUploads().then((previousUploads) => {
-        const previousUpload = previousUploads[0];
-        if (previousUpload) {
-          tusUpload.resumeFromPreviousUpload(previousUpload);
-        }
-        tusUpload.start();
-      });
-    }
-  }
-
-  function startAll(): void {
-    const pending = uploads.value.filter((u) => u.status === 'idle' || u.status === 'paused');
-    const currentlyUploading = uploads.value.filter((u) => u.status === 'uploading').length;
-    const limit = (defaultConfig.parallelUploads || 3) - currentlyUploading;
-
-    pending.slice(0, Math.max(0, limit)).forEach((item) => startUpload(item.id));
-  }
-
-  function pauseUpload(id: string): void {
-    const tusUpload = tusUploads.value.get(id);
-    if (tusUpload) {
-      tusUpload.abort();
-      updateItem(id, { status: 'paused' });
-    }
-  }
-
-  function pauseAll(): void {
-    uploads.value.filter((u) => u.status === 'uploading').forEach((item) => pauseUpload(item.id));
-  }
-
-  function resumeUpload(id: string): void {
-    startUpload(id);
-  }
-
-  function resumeAll(): void {
-    uploads.value.filter((u) => u.status === 'paused').forEach((item) => resumeUpload(item.id));
-  }
-
-  function cancelUpload(id: string): void {
-    const tusUpload = tusUploads.value.get(id);
-    if (tusUpload) {
-      tusUpload.abort();
-    }
-    tusUploads.value.delete(id);
-
-    const newMap = new Map(uploadItems.value);
-    newMap.delete(id);
-    uploadItems.value = newMap;
-  }
-
-  function cancelAll(): void {
-    uploads.value.forEach((item) => cancelUpload(item.id));
-  }
-
-  function removeUpload(id: string): void {
-    cancelUpload(id);
-  }
-
-  function clearCompleted(): void {
-    uploads.value.filter((u) => u.status === 'completed').forEach((item) => removeUpload(item.id));
-  }
-
-  function retryUpload(id: string): void {
-    const item = uploadItems.value.get(id);
-    if (item && item.status === 'error') {
-      updateItem(id, { error: undefined, status: 'idle' });
-      startUpload(id);
-    }
-  }
-
-  function getUpload(id: string): undefined | UploadItem {
-    return uploadItems.value.get(id);
-  }
-
-  return {
-    addFiles,
-    cancelAll,
-    cancelUpload,
-    clearCompleted,
-    getUpload,
-    isUploading,
-    pauseAll,
-    pauseUpload,
-    removeUpload,
-    resumeAll,
-    resumeUpload,
-    retryUpload,
-    startAll,
-    startUpload,
-    totalProgress,
-    uploads,
-  };
-}

package/nuxt-base-template/app/composables/use-tw.ts

@@ -1 +0,0 @@
-export const tw = <T extends string | TemplateStringsArray>(tailwindClasses: T) => tailwindClasses;

package/nuxt-base-template/app/interfaces/upload.interface.ts

@@ -1,58 +0,0 @@
-import type { ComputedRef } from 'vue';
-
-export interface UploadItem {
-  completedAt?: Date;
-  error?: string;
-  file: File;
-  id: string;
-  metadata?: Record<string, string>;
-  progress: UploadProgress;
-  startedAt?: Date;
-  status: UploadStatus;
-  url?: string;
-}
-
-export interface UploadOptions {
-  autoStart?: boolean;
-  chunkSize?: number;
-  endpoint?: string;
-  headers?: Record<string, string>;
-  metadata?: Record<string, string>;
-  onError?: (item: UploadItem, error: Error) => void;
-  onProgress?: (item: UploadItem) => void;
-  onSuccess?: (item: UploadItem) => void;
-  parallelUploads?: number;
-  retryDelays?: number[];
-}
-
-export interface UploadProgress {
-  bytesTotal: number;
-  bytesUploaded: number;
-  percentage: number;
-  remainingTime: number; // seconds
-  speed: number; // bytes/second
-}
-
-export type UploadStatus = 'completed' | 'error' | 'idle' | 'paused' | 'uploading';
-
-export interface UseTusUploadReturn {
-  // Actions
-  addFiles: (files: File | File[]) => string[];
-  cancelAll: () => void;
-  cancelUpload: (id: string) => void;
-  clearCompleted: () => void;
-  getUpload: (id: string) => undefined | UploadItem;
-
-  // State
-  isUploading: ComputedRef<boolean>;
-  pauseAll: () => void;
-  pauseUpload: (id: string) => void;
-  removeUpload: (id: string) => void;
-  resumeAll: () => void;
-  resumeUpload: (id: string) => void;
-  retryUpload: (id: string) => void;
-  startAll: () => void;
-  startUpload: (id: string) => void;
-  totalProgress: ComputedRef<UploadProgress>;
-  uploads: ComputedRef<UploadItem[]>;
-}

package/nuxt-base-template/app/lib/auth-client.ts

@@ -1,229 +0,0 @@
-import { passkeyClient } from '@better-auth/passkey/client';
-import { adminClient, twoFactorClient } from 'better-auth/client/plugins';
-import { createAuthClient } from 'better-auth/vue';
-
-import { authFetch } from '~/lib/auth-state';
-import { sha256 } from '~/utils/crypto';
-
-// =============================================================================
-// Type Definitions
-// =============================================================================
-
-/**
- * Normalized response type for Better-Auth operations
- * The Vue client returns complex union types - this provides a consistent interface
- */
-export interface AuthResponse {
-  data?: null | {
-    redirect?: boolean;
-    token?: null | string;
-    url?: string;
-    user?: {
-      createdAt?: Date;
-      email?: string;
-      emailVerified?: boolean;
-      id?: string;
-      image?: string;
-      name?: string;
-      updatedAt?: Date;
-    };
-  };
-  error?: null | {
-    code?: string;
-    message?: string;
-    status?: number;
-  };
-}
-
-/**
- * Configuration options for the auth client factory
- * All options have sensible defaults for nest-server compatibility
- */
-export interface AuthClientConfig {
-  /** API base URL (default: from env or http://localhost:3000) */
-  baseURL?: string;
-  /** Auth API base path (default: '/iam' - must match nest-server betterAuth.basePath) */
-  basePath?: string;
-  /** 2FA redirect path (default: '/auth/2fa') */
-  twoFactorRedirectPath?: string;
-  /** Enable admin plugin (default: true) */
-  enableAdmin?: boolean;
-  /** Enable 2FA plugin (default: true) */
-  enableTwoFactor?: boolean;
-  /** Enable passkey plugin (default: true) */
-  enablePasskey?: boolean;
-}
-
-// =============================================================================
-// Auth Client Factory
-// =============================================================================
-
-/**
- * Creates a configured Better-Auth client with password hashing
- *
- * This factory function allows creating auth clients with custom configuration,
- * making it reusable across different projects.
- *
- * @example
- * ```typescript
- * // Default configuration (works with nest-server defaults)
- * const authClient = createBetterAuthClient();
- *
- * // Custom configuration
- * const authClient = createBetterAuthClient({
- *   baseURL: 'https://api.example.com',
- *   basePath: '/auth',
- *   twoFactorRedirectPath: '/login/2fa',
- * });
- * ```
- *
- * SECURITY: Passwords are hashed with SHA256 client-side to prevent
- * plain text password transmission over the network.
- */
-export function createBetterAuthClient(config: AuthClientConfig = {}) {
-  // In development, use empty baseURL and /api/iam path to leverage Nuxt server proxy
-  // This is REQUIRED for WebAuthn/Passkey to work correctly because:
-  // - Frontend runs on localhost:3002, API on localhost:3000
-  // - WebAuthn validates the origin, which must be consistent
-  // - The Nuxt server proxy ensures requests come from the frontend origin
-  // Note: In Nuxt, use import.meta.dev (not import.meta.env?.DEV which is Vite-specific)
-  // At lenne.tech, 'development' is a stage on a web server, 'local' is the local dev environment
-  const isDev = import.meta.dev || process.env.NODE_ENV === 'local';
-  const defaultBaseURL = isDev ? '' : import.meta.env?.VITE_API_URL || process.env.API_URL || 'http://localhost:3000';
-  const defaultBasePath = isDev ? '/api/iam' : '/iam';
-
-  const { baseURL = defaultBaseURL, basePath = defaultBasePath, twoFactorRedirectPath = '/auth/2fa', enableAdmin = true, enableTwoFactor = true, enablePasskey = true } = config;
-
-  // Build plugins array based on configuration
-  const plugins: any[] = [];
-
-  if (enableAdmin) {
-    plugins.push(adminClient());
-  }
-
-  if (enableTwoFactor) {
-    plugins.push(
-      twoFactorClient({
-        onTwoFactorRedirect() {
-          navigateTo(twoFactorRedirectPath);
-        },
-      }),
-    );
-  }
-
-  if (enablePasskey) {
-    plugins.push(passkeyClient());
-  }
-
-  // Create base client with configuration
-  // Uses authFetch for automatic Cookie/JWT dual-mode authentication
-  const baseClient = createAuthClient({
-    basePath,
-    baseURL,
-    fetchOptions: {
-      customFetchImpl: authFetch,
-    },
-    plugins,
-  });
-
-  // Return extended client with password hashing
-  return {
-    // Spread all base client properties and methods
-    ...baseClient,
-
-    // Explicitly pass through methods not captured by spread operator
-    useSession: baseClient.useSession,
-    passkey: (baseClient as any).passkey,
-    admin: (baseClient as any).admin,
-    $Infer: baseClient.$Infer,
-    $fetch: baseClient.$fetch,
-    $store: baseClient.$store,
-
-    /**
-     * Change password for an authenticated user (both passwords are hashed)
-     */
-    changePassword: async (params: { currentPassword: string; newPassword: string }, options?: any) => {
-      const [hashedCurrent, hashedNew] = await Promise.all([sha256(params.currentPassword), sha256(params.newPassword)]);
-      return baseClient.changePassword?.({ currentPassword: hashedCurrent, newPassword: hashedNew }, options);
-    },
-
-    /**
-     * Reset password with token (new password is hashed before sending)
-     */
-    resetPassword: async (params: { newPassword: string; token: string }, options?: any) => {
-      const hashedPassword = await sha256(params.newPassword);
-      return baseClient.resetPassword?.({ newPassword: hashedPassword, token: params.token }, options);
-    },
-
-    // Override signIn to hash password (keep passkey method from plugin)
-    signIn: {
-      ...baseClient.signIn,
-      /**
-       * Sign in with email and password (password is hashed before sending)
-       */
-      email: async (params: { email: string; password: string; rememberMe?: boolean }, options?: any) => {
-        const hashedPassword = await sha256(params.password);
-        return baseClient.signIn.email({ ...params, password: hashedPassword }, options);
-      },
-      /**
-       * Sign in with passkey (pass through to base client - provided by passkeyClient plugin)
-       * @see https://www.better-auth.com/docs/plugins/passkey
-       */
-      passkey: (baseClient.signIn as any).passkey,
-    },
-
-    // Explicitly pass through signOut (not captured by spread operator)
-    signOut: baseClient.signOut,
-
-    // Override signUp to hash password
-    signUp: {
-      ...baseClient.signUp,
-      /**
-       * Sign up with email and password (password is hashed before sending)
-       */
-      email: async (params: { email: string; name: string; password: string }, options?: any) => {
-        const hashedPassword = await sha256(params.password);
-        return baseClient.signUp.email({ ...params, password: hashedPassword }, options);
-      },
-    },
-
-    // Override twoFactor to hash passwords (provided by twoFactorClient plugin)
-    twoFactor: {
-      ...(baseClient as any).twoFactor,
-      /**
-       * Disable 2FA (password is hashed before sending)
-       */
-      disable: async (params: { password: string }, options?: any) => {
-        const hashedPassword = await sha256(params.password);
-        return (baseClient as any).twoFactor.disable({ password: hashedPassword }, options);
-      },
-      /**
-       * Enable 2FA (password is hashed before sending)
-       */
-      enable: async (params: { password: string }, options?: any) => {
-        const hashedPassword = await sha256(params.password);
-        return (baseClient as any).twoFactor.enable({ password: hashedPassword }, options);
-      },
-      /**
-       * Verify TOTP code (pass through to base client)
-       */
-      verifyTotp: (baseClient as any).twoFactor.verifyTotp,
-      /**
-       * Verify backup code (pass through to base client)
-       */
-      verifyBackupCode: (baseClient as any).twoFactor.verifyBackupCode,
-    },
-  };
-}
-
-// =============================================================================
-// Default Auth Client Instance
-// =============================================================================
-
-/**
- * Default auth client instance with standard nest-server configuration
- * Use createBetterAuthClient() for custom configuration
- */
-export const authClient = createBetterAuthClient();
-
-export type AuthClient = ReturnType<typeof createBetterAuthClient>;