/*
 * Step 1: Initialize a new Node.js project and install dependencies.
 * We start by setting up our environment for Prisma and TypeScript.
 */

// Initialize npm project
// npm init -y

// Install TypeScript and ts-node for local development
// npm install typescript ts-node @types/node --save-dev

// Install Prisma CLI as a development dependency
// npm install prisma --save-dev

// Install Prisma Client as a runtime dependency
// npm install @prisma/client

/*
 * Step 2: Initialize Prisma within your project.
 * This command sets up a basic `schema.prisma` file and a `.env` file.
 * Prisma will create the `prisma` directory containing `schema.prisma`.
 */

// npx prisma init --datasource-provider postgresql

/*
 * Step 3: Define your schema.prisma file.
 * This schema dictates your database structure and how Prisma generates types.
 * Example: A simple User model with an ID, email, and name.
 */

// prisma/schema.prisma
/*
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id    String @id @default(uuid())
  email String @unique
  name  String?
}
*/

/*
 * Step 4: Generate the Prisma Client.
 * This command reads your `schema.prisma` and generates the TypeScript client
 * within `node_modules/@prisma/client`.
 * It must be run every time the `schema.prisma` file changes.
 */

// npx prisma generate

// After generation, you can import and use `PrismaClient` in your TypeScript code.
// import { PrismaClient } from '@prisma/client';
// const prisma = new PrismaClient();

/*
 * Step 5: Implement database operations using the generated Prisma Client.
 * We demonstrate how Prisma's types enforce safety during data creation and retrieval.
 */

// src/index.ts (or main application file)

import { PrismaClient, User } from '@prisma/client';

// Instantiate the Prisma Client. This manages database connections.
const prisma = new PrismaClient();

async function main() {
  try {
    // --- Create a new User (Type Safety in Action) ---
    // The 'create' method expects an object matching 'Prisma.UserCreateInput'.
    // TypeScript will flag missing required fields or incorrect types.
    console.log('Creating a new user...');
    const newUser: User = await prisma.user.create({
      data: {
        email: `user_${Date.now()}@example.com`,
        name: 'John Doe',
      },
    });
    console.log('Created user:', newUser);

    // Example of a type error (uncomment to see TS error):
    // await prisma.user.create({
    //   data: {
    //     // email: 'invalid-user@example.com', // Missing required email field if commented out
    //     age: 30 // 'age' is not defined in the User model; TS detects this!
    //   }
    // });

    // --- Retrieve Users (Typed Results) ---
    // The 'findMany' method returns an array of 'User' type.
    console.log('\nRetrieving all users...');
    const allUsers: User[] = await prisma.user.findMany();
    console.log('All users:', allUsers);

    // --- Update a User (Typed Input and Output) ---
    // 'update' expects 'Prisma.UserUpdateInput' and returns 'User'.
    if (newUser) {
      console.log(`\nUpdating user ${newUser.id}...`);
      const updatedUser: User = await prisma.user.update({
        where: { id: newUser.id },
        data: { name: 'Jane Doe' },
      });
      console.log('Updated user:', updatedUser);
    }

  } catch (error) {
    // PrismaClientKnownRequestError handles known database errors (e.g., unique constraint violation)
    // Generic 'Error' for other issues.
    if (error instanceof Error) {
      console.error('An error occurred:', error.message);
    }
  } finally {
    // Ensure the database connection is closed gracefully.
    await prisma.$disconnect();
  }
}

main();

/*
 * Step 6: Explore advanced Prisma and TypeScript patterns for enhanced database safety.
 * We demonstrate transactions, custom types, and type-safe middleware.
 */

import { PrismaClient, User, Prisma } from '@prisma/client';
import { z } from 'zod'; // For schema validation (npm install zod)

const prisma = new PrismaClient();

// 1. Defining a Zod schema for input validation, layered on Prisma's types
// This adds an extra layer of runtime validation, complementing TS compile-time checks.
const createUserSchema = z.object({
  email: z.string().email('Invalid email address'),
  name: z.string().min(3, 'Name must be at least 3 characters').optional(),
});

// 2. Type-Safe Middleware for logging or validation
// Middleware can intercept and modify queries, ensuring consistency across operations.
prisma.$use(async (params, next) => {
  console.log(`Query: ${params.model}.${params.action}`);
  // Example: Check if a delete operation is allowed for certain models
  if (params.model === 'User' && params.action === 'delete') {
    // Implement custom logic, e.g., soft delete instead of hard delete
    // return prisma.user.update({ where: params.args.where, data: { isActive: false } });
    // For this example, we'll just log and proceed.
  }
  const result = await next(params);
  return result;
});

async function advancedOperations() {
  try {
    // --- Transactional Operations with Type Safety ---
    // We ensure atomicity and type safety across multiple related operations.
    console.log('\nExecuting a transaction...');
    const [newUser, updatedUser] = await prisma.$transaction<[User, User]>([
      prisma.user.create({
        data: {
          email: `transaction_user_${Date.now()}@example.com`,
          name: 'Transaction User 1',
        },
      }),
      prisma.user.update({
        where: { email: 'user_1678888888888@example.com' }, // Replace with an actual email or dynamic value
        data: { name: 'Updated Transaction User' },
      }),
    ]).catch(e => {
        console.error('Transaction failed:', e.message);
        // Rollback is automatic with Prisma transactions on error.
        throw e;
    });
    console.log('Transaction results: New User:', newUser, 'Updated User:', updatedUser);

    // --- Using Zod for input validation before Prisma operation ---
    console.log('\nValidating input with Zod...');
    const userInput = { email: 'validated@example.com', name: 'Valid User' };
    const validatedInput = createUserSchema.parse(userInput);
    const createdValidatedUser: User = await prisma.user.create({
      data: validatedInput,
    });
    console.log('Created validated user:', createdValidatedUser);

  } catch (error) {
    if (error instanceof Error) {
      console.error('An advanced error occurred:', error.message);
      if (error instanceof z.ZodError) {
        console.error('Validation errors:', error.errors);
      }
    }
  } finally {
    await prisma.$disconnect();
  }
}

advancedOperations();

/*
 * Step 7: Establish best practices for deploying and maintaining Prisma with TypeScript.
 * We cover schema migrations, connection pooling, and project structure.
 */

// --- Database Migrations --- 
// Prisma Migrate manages schema changes and applies them to your database.
// It creates SQL migration files and records their execution.

// Create a new migration based on schema.prisma changes
// npx prisma migrate dev --name init

// Apply pending migrations to a target database (e.g., in production)
// npx prisma migrate deploy

// Reset your development database and apply all migrations
// npx prisma migrate reset

// --- Prisma Client Instantiation Best Practice ---
// Avoid creating a new PrismaClient instance on every request/module import.
// Use a singleton pattern to ensure a single, shared instance for connection pooling.

// src/utils/prisma.ts

/*
import { PrismaClient } from '@prisma/client';

// Declare a global variable to store the PrismaClient instance
// This prevents hot-reloading from creating multiple instances in development.
declare global {
  var prisma: PrismaClient | undefined;
}

let prisma: PrismaClient;

if (process.env.NODE_ENV === 'production') {
  prisma = new PrismaClient();
} else {
  // In development, store the instance globally to prevent new connections on hot-reload.
  if (!global.prisma) {
    global.prisma = new PrismaClient();
  }
  prisma = global.prisma;
}

export default prisma;
*/

// --- Integration with CI/CD (Example in a hypothetical .gitlab-ci.yml or .github/workflows/main.yml) ---
/*
  stages:
    - build
    - test
    - deploy

  # Example CI/CD job to ensure schema is up-to-date and generate client
  build_job:
    stage: build
    script:
      - npm install
      - npx prisma validate --schema=prisma/schema.prisma  # Validate schema syntax
      - npx prisma generate                             # Ensure client is generated
      - npm run build                                   # Compile TypeScript code

  # Example CI/CD job for testing against a test database
  test_job:
    stage: test
    services:
      - postgres:latest # Use a Dockerized PostgreSQL for tests
    variables:
      DATABASE_URL: 'postgresql://user:password@postgres:5432/testdb'
    script:
      - npm install
      - npx prisma migrate deploy # Apply migrations to the test database
      - npm test                  # Run your application tests
*/