yinzerflow 0.1.18 → 0.2.0

package/example/hooks/authentication.middleware.ts

@@ -1,77 +0,0 @@
-/**
- * Authentication Middleware
- *
- * This middleware checks for a valid authentication token in the request headers.
- * If no token is provided or the token is invalid, it returns an unauthorized response.
- */
-
-import { HttpStatusCode } from 'yinzerflow';
-import type { Context, THttpStatusCode, TResponseBody } from 'yinzerflow';
-
-// Define user interface
-interface User {
-  id: string;
-  name: string;
-  role: string;
-}
-
-// Define response interface
-interface AuthResponse {
-  success: boolean;
-  message: string;
-  error?: string;
-}
-
-// Extend the request type to include user property
-declare module 'yinzerflow' {
-  interface HttpRequest {
-    user?: User;
-  }
-}
-
-// Simulated user database for demo purposes
-const USERS: Record<string, User> = {
-  'user123-token': { id: 'user123', name: 'John Doe', role: 'user' },
-  'admin456-token': { id: 'admin456', name: 'Jane Smith', role: 'admin' },
-};
-
-/**
- * Authentication middleware function
- * Validates the auth token and attaches user data to the request if valid
- */
-export default ({ request, response }: Context): TResponseBody<AuthResponse> | void => {
-  // Get the authorization header
-  const authHeader = request.headers['authorization'];
-
-  // Check if the authorization header exists and has the correct format
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    response.setStatus(HttpStatusCode.UNAUTHORIZED as THttpStatusCode);
-    return {
-      success: false,
-      message: 'Authentication required',
-      error: 'Missing or invalid authorization header',
-    };
-  }
-
-  // Extract the token
-  const token = authHeader.split(' ')[1];
-
-  // Check if the token exists in our simulated database
-  const user = USERS[token];
-
-  if (!user) {
-    response.setStatus(HttpStatusCode.UNAUTHORIZED as THttpStatusCode);
-    return {
-      success: false,
-      message: 'Authentication failed',
-      error: 'Invalid token',
-    };
-  }
-
-  // If we reach here, the token is valid
-  // Attach the user data to the request for use in route handlers
-  request.user = user;
-
-  // Continue to the next middleware or route handler
-  // By not returning anything, we allow the request to proceed
-};

package/example/package.json

@@ -1,61 +0,0 @@
-{
-  "name": "yinzerflow",
-  "version": "0.1.10",
-  "author": "Patrick Rizzardi <patrick@redact.digital> (https://redact.digital)",
-  "license": "MIT",
-  "homepage": "https://github.com/yinzers/YinzerFlow.git",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yinzers/YinzerFlow.git"
-  },
-  "description": "A simple, fast, and lightweight web framework for Node and Bun",
-  "keywords": [
-    "http",
-    "rest",
-    "server",
-    "router",
-    "app",
-    "api",
-    "web",
-    "framework",
-    "node",
-    "bun",
-    "yinzerflow"
-  ],
-  "types": "index.d.ts",
-  "main": "index.js",
-  "type": "module",
-  "scripts": {
-    "test": "bun test --watch --coverage --ignore-coverage-for-files=app/core/__mocks__",
-    "test:production": "bun test --timeout 20 --rerun-each 10 --bail 10",
-    "clean": "rm -rf lib && rm -rf storage && echo 'Done.'",
-    "build": "bun clean; bun build.ts",
-    "start": "bun --watch local/index.ts",
-    "lint": "eslint . --fix --quiet --color --cache",
-    "lint:format": "prettier --check .",
-    "lint:spelling": "cspell . --no-progress --unique",
-    "lint:size": "gzip-size lib/index.js --include-original",
-    "format": "prettier --write app"
-  },
-  "dependencies": {
-    "yinzerflow": "file:../lib"
-  },
-  "devDependencies": {
-    "@eslint/compat": "^1.2.7",
-    "@types/ip": "^1.1.3",
-    "bun-plugin-dts": "^0.3.0",
-    "bun-types": "1.0.3",
-    "cspell": "^8.17.5",
-    "eslint": "^9.22.0",
-    "eslint-import-resolver-typescript": "^3.8.5",
-    "eslint-plugin-import": "^2.31.0",
-    "globals": "^15.15.0",
-    "gzip-size-cli": "^5.1.0",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.26.1"
-  },
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  }
-}

package/example/routes/authentication.routes.ts

@@ -1,243 +0,0 @@
-/**
- * Authentication Routes
- *
- * This file defines routes for user authentication including:
- * - User registration
- * - User login
- * - User logout
- * - User profile retrieval
- */
-
-import { HttpStatusCode } from 'yinzerflow';
-import type { Context,  IRoute,  THttpStatusCode, TResponseBody } from 'yinzerflow';
-
-// Define interfaces for better type safety
-interface User {
-  id: string;
-  email: string;
-  password: string;
-  name: string;
-}
-
-interface UserResponse {
-  id: string;
-  email: string;
-  name: string;
-}
-
-interface AuthResponse {
-  success: boolean;
-  message: string;
-  user?: UserResponse;
-  token?: string;
-  error?: string;
-  errors?: Record<string, string | null>;
-}
-
-// Mock database for demonstration
-const users: User[] = [
-  {
-    id: '1',
-    email: 'user@example.com',
-    password: 'password123', // In a real app, this would be hashed
-    name: 'Example User',
-  },
-];
-
-// Mock tokens for demonstration
-const tokens: Record<string, string> = {};
-
-/**
- * Authentication routes
- */
-export default <IRoute[]>[
-  // Register a new user
-  {
-    path: '/register',
-    method: 'POST',
-    handler: ({ request, response }: Context): TResponseBody<AuthResponse> => {
-      const { email, password, name } = request.body as {
-        email?: string;
-        password?: string;
-        name?: string;
-      };
-
-      // Validate input
-      const errors: Record<string, string | null> = {
-        email: !email ? 'Email is required' : null,
-        password: !password ? 'Password is required' : null,
-        name: !name ? 'Name is required' : null,
-      };
-
-      // Check if any errors exist
-      const hasErrors = Object.values(errors).some((error) => error !== null);
-      if (hasErrors) {
-        response.setStatus(HttpStatusCode.BAD_REQUEST as THttpStatusCode);
-        return {
-          success: false,
-          message: 'Validation failed',
-          errors: Object.fromEntries(Object.entries(errors).filter(([_, value]) => value !== null)),
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Check if user already exists
-      const existingUser = users.find((u) => u.email === email);
-      if (existingUser) {
-        response.setStatus(HttpStatusCode.BAD_REQUEST as THttpStatusCode);
-        return {
-          success: false,
-          message: 'User already exists',
-          error: 'Email already in use',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Create new user
-      const newUser: User = {
-        id: (users.length + 1).toString(),
-        email: email!,
-        password: password!, // In a real app, this would be hashed
-        name: name!,
-      };
-
-      users.push(newUser);
-
-      // Generate token
-      const token = `token_${Date.now()}_${newUser.id}`;
-      tokens[newUser.id] = token;
-
-      response.setStatus(HttpStatusCode.CREATED as THttpStatusCode);
-      return {
-        success: true,
-        message: 'User registered successfully',
-        user: {
-          id: newUser.id,
-          email: newUser.email,
-          name: newUser.name,
-        },
-        token,
-      } as TResponseBody<AuthResponse>;
-    },
-  },
-
-  // Login user
-  {
-    path: '/login',
-    method: 'POST',
-    handler: ({ request, response }: Context): TResponseBody<AuthResponse> => {
-      const { email, password } = request.body as {
-        email?: string;
-        password?: string;
-      };
-
-      // Validate input
-      if (!email || !password) {
-        response.setStatus(HttpStatusCode.BAD_REQUEST as THttpStatusCode);
-        return {
-          success: false,
-          message: 'Email and password are required',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Find user
-      const user = users.find((u) => u.email === email && u.password === password);
-      if (!user) {
-        response.setStatus(HttpStatusCode.UNAUTHORIZED as THttpStatusCode);
-        return {
-          success: false,
-          message: 'Invalid credentials',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Generate token
-      const token = `token_${Date.now()}_${user.id}`;
-      tokens[user.id] = token;
-
-      return {
-        success: true,
-        message: 'Login successful',
-        user: {
-          id: user.id,
-          email: user.email,
-          name: user.name,
-        },
-        token,
-      } as TResponseBody<AuthResponse>;
-    },
-  },
-
-  // Get user profile
-  {
-    path: '/profile/:id',
-    method: 'GET',
-    handler: ({ request, response  }: Context): TResponseBody<AuthResponse> => {
-      const { id } = <{ id: string }>request.params;
-      const authHeader = request.headers.Authorization;
-
-      // Check if user exists
-      const user = users.find((u) => u.id === id);
-      if (!user) {
-        response.setStatus(HttpStatusCode.NOT_FOUND as THttpStatusCode);
-        return {
-          success: false,
-          message: 'User not found',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Validate token
-      const expectedToken = tokens[id];
-      if (!authHeader || !authHeader.startsWith('Bearer ') || authHeader.split(' ')[1] !== expectedToken) {
-        response.setStatus(HttpStatusCode.UNAUTHORIZED as THttpStatusCode);
-        return {
-          success: false,
-          message: 'Unauthorized',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      return {
-        success: true,
-        message: 'Profile retrieved successfully',
-        user: {
-          id: user.id,
-          email: user.email,
-          name: user.name,
-        },
-      } as TResponseBody<AuthResponse>;
-    },
-  },
-
-  // Logout user
-  {
-    path: '/logout',
-    method: 'POST',
-    handler: ({ request, response }: Context): TResponseBody<AuthResponse> => {
-      const authHeader = request.headers.Authorization;
-
-      if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        response.setStatus(HttpStatusCode.BAD_REQUEST as THttpStatusCode);
-        return {
-          success: false,
-          message: 'No token provided',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      const token = authHeader.split(' ')[1];
-      const userId = Object.keys(tokens).find((id) => tokens[id] === token);
-
-      if (!userId) {
-        response.setStatus(HttpStatusCode.UNAUTHORIZED as THttpStatusCode);
-        return {
-          success: false,
-          message: 'Invalid token',
-        } as TResponseBody<AuthResponse>;
-      }
-
-      // Remove token
-      delete tokens[userId];
-
-      return {
-        success: true,
-        message: 'Logout successful',
-      } as TResponseBody<AuthResponse>;
-    },
-  },
-];

package/example/routes/content-types.ts

@@ -1,116 +0,0 @@
-import { IMultipartFormData, isJsonData, isMultipartFormData, TJsonData, YinzerFlow } from 'yinzerflow';
-
-/**
- * This file demonstrates different approaches to handle various content types:
- * 1. Fast approach using type casting (no runtime checks)
- * 2. Safe approach using type guards (with runtime validation)
- */
-export default function setupContentHandlers(app: YinzerFlow) {
-  //=============================================================================
-  // JSON Data Handlers
-  //=============================================================================
-
-  /**
-   * Fast approach for JSON data (using type casting)
-   */
-  app.post('/api/json/fast', ({ request }) => {
-    // Use type assertion - fast but no runtime validation
-    const body = request.body as TJsonData<{ name: string; email: string; preferences: Record<string, unknown> }>;
-
-    // Access properties directly
-    const { name, email, preferences } = body;
-
-    return {
-      success: true,
-      message: `Processed JSON data for ${name}`,
-      emailConfirmed: !!email,
-      preferencesCount: preferences ? Object.keys(preferences).length : 0,
-    };
-  });
-
-  /**
-   * Safe approach for JSON data (using type guards)
-   */
-  app.post('/api/json/safe', ({ request, response }) => {
-    // Runtime type checking
-    if (!isJsonData<{ name: string; email: string; preferences: Record<string, unknown> }>(request.body)) {
-      response.setStatus(400);
-      return {
-        success: false,
-        message: 'Expected JSON data',
-      };
-    }
-
-    // TypeScript knows request.body is JsonData here
-    const body = request.body;
-
-    // Validate required fields
-    if (!body.name || typeof body.name !== 'string') {
-      response.setStatus(400);
-      return {
-        success: false,
-        message: 'Missing or invalid required field: name',
-      };
-    }
-
-    return {
-      success: true,
-      message: `Processed JSON data for ${body.name}`,
-      receivedFields: Object.keys(body),
-    };
-  });
-
-  //=============================================================================
-  // Multipart Form Data Handlers
-  //=============================================================================
-
-  /**
-   * Fast approach for multipart form data (using type casting)
-   */
-  app.post('/api/multipart/fast', ({ request }) => {
-    // Use type assertion - fast but no runtime validation
-    const body = request.body as IMultipartFormData;
-
-    // Access form fields and files
-    const { fields, files } = body;
-
-    return {
-      success: true,
-      message: 'Processed multipart form data',
-      fieldCount: Object.keys(fields).length,
-      fileCount: Object.keys(files).length,
-      fileNames: Object.keys(files),
-    };
-  });
-
-  /**
-   * Safe approach for multipart form data (using type guards)
-   */
-  app.post('/api/multipart/safe', ({ request, response }) => {
-    // Runtime type checking
-    if (!isMultipartFormData(request.body)) {
-      response.setStatus(400);
-      return {
-        success: false,
-        message: 'Expected multipart form data',
-      };
-    }
-
-    // TypeScript knows request.body is MultipartFormData here
-    const { fields, files } = request.body;
-
-    // Process files
-    const fileInfo = Object.entries(files).map(([name, file]) => ({
-      name,
-      size: file.size,
-      contentType: file.contentType,
-    }));
-
-    return {
-      success: true,
-      message: 'Processed multipart form data',
-      fields,
-      files: fileInfo,
-    };
-  });
-}

package/example/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "allowImportingTsExtensions": true,
-    "outDir": "dist",
-    "declaration": true,
-    "sourceMap": true,
-    "types": [
-      "bun-types"
-    ],
-    "baseUrl": ".",
-    "paths": {
-      "yinzerflow": [
-        "../lib",
-        "../lib/index.d.ts"
-      ]
-    }
-  },
-  "include": [
-    "./**/*.ts"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}