Penyelesaian Penyewa Berasaskan Subdomain dan Laluan

// lib/tenant/resolveSubdomain.ts
export function resolveSubdomain(
  hostname: string,
  rootDomain: string   // e.g. 'app.com'
): string | null {
  // Strip port if present (e.g. localhost:3000)
  const host = hostname.split(':')[0];

  if (host === 'localhost' || host === '127.0.0.1') {
    return null; // handled separately in dev
  }

  if (!host.endsWith(`.${rootDomain}`)) {
    return null; // top-level domain — no tenant
  }

  const subdomain = host.slice(0, host.length - rootDomain.length - 1);
  if (subdomain === 'www' || subdomain === '') return null;

  return subdomain; // e.g. 'acme'
}

// lib/tenant/resolvePath.ts
export function resolvePathTenant(
  pathname: string
): { tenant: string | null; strippedPath: string } {
  const segments = pathname.split('/').filter(Boolean);

  if (segments.length === 0) {
    return { tenant: null, strippedPath: '/' };
  }

  // First segment is treated as the tenant slug.
  // Validation against a real slug set happens in middleware.
  const [tenantSlug, ...rest] = segments;
  const strippedPath = '/' + rest.join('/');

  return { tenant: tenantSlug, strippedPath: strippedPath || '/' };
}

// middleware.ts — path-based rewrite example
import { NextRequest, NextResponse } from 'next/server';
import { resolvePathTenant } from './lib/tenant/resolvePath';

const ROOT_DOMAIN = process.env.NEXT_PUBLIC_ROOT_DOMAIN ?? 'app.com';

export function middleware(request: NextRequest) {
  const { tenant, strippedPath } = resolvePathTenant(
    request.nextUrl.pathname
  );

  if (!tenant) return NextResponse.next();

  const url = request.nextUrl.clone();
  url.pathname = strippedPath;

  const requestHeaders = new Headers(request.headers);
  requestHeaders.set('x-tenant-slug', tenant);

  return NextResponse.rewrite(url, {
    request: { headers: requestHeaders },
  });
}

export const config = {
  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
};

// middleware.ts — unified resolver
import { NextRequest, NextResponse } from 'next/server';
import { resolveSubdomain } from './lib/tenant/resolveSubdomain';
import { resolvePathTenant } from './lib/tenant/resolvePath';

const ROOT_DOMAIN = process.env.NEXT_PUBLIC_ROOT_DOMAIN ?? 'app.com';

export function middleware(request: NextRequest) {
  const { hostname, pathname } = request.nextUrl;

  // 1. Try subdomain first
  let tenantSlug = resolveSubdomain(hostname, ROOT_DOMAIN);
  let rewritePath: string | null = null;

  // 2. Fall back to path prefix
  if (!tenantSlug) {
    const result = resolvePathTenant(pathname);
    tenantSlug = result.tenant;
    rewritePath = result.strippedPath;
  }

  if (!tenantSlug) return NextResponse.next(); // public route

  const requestHeaders = new Headers(request.headers);
  requestHeaders.set('x-tenant-slug', tenantSlug);

  if (rewritePath) {
    const url = request.nextUrl.clone();
    url.pathname = rewritePath;
    return NextResponse.rewrite(url, { request: { headers: requestHeaders } });
  }

  // Subdomain path — no URL rewrite needed, just forward the header
  return NextResponse.next({ request: { headers: requestHeaders } });
}

export const config = {
  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
};

// lib/tenant/server.ts
import { headers } from 'next/headers';
import { cache } from 'react';
import { db } from '@/lib/db'; // your DB client

export async function getTenantSlug(): Promise<string> {
  const headerStore = await headers();
  const slug = headerStore.get('x-tenant-slug');
  if (!slug) throw new Error('No tenant slug in request headers');
  return slug;
}

// Cached per request — React deduplicates across the component tree
export const getTenant = cache(async () => {
  const slug = await getTenantSlug();
  const tenant = await db.tenant.findUnique({ where: { slug } });
  if (!tenant) throw new Error(`Unknown tenant: ${slug}`);
  return tenant;
});

// Usage inside any Server Component:
// const tenant = await getTenant();
// <ThemeProvider primary={tenant.brandColor}>...</ThemeProvider>

// middleware.ts — Edge KV validation with Upstash Redis
import { NextRequest, NextResponse } from 'next/server';
import { Redis } from '@upstash/redis';
import { resolveSubdomain } from './lib/tenant/resolveSubdomain';

const redis = Redis.fromEnv();
const ROOT_DOMAIN = process.env.NEXT_PUBLIC_ROOT_DOMAIN ?? 'app.com';

export async function middleware(request: NextRequest) {
  const { hostname } = request.nextUrl;
  const tenantSlug = resolveSubdomain(hostname, ROOT_DOMAIN);

  if (!tenantSlug) return NextResponse.next();

  // 'tenants' is a Redis Set populated whenever a tenant is created/deleted
  const exists = await redis.sismember('tenants', tenantSlug);
  if (!exists) {
    return NextResponse.redirect(
      new URL('/tenant-not-found', request.url)
    );
  }

  const requestHeaders = new Headers(request.headers);
  requestHeaders.set('x-tenant-slug', tenantSlug);
  return NextResponse.next({ request: { headers: requestHeaders } });
}

export const config = { matcher: ['/((?!_next|favicon.ico).*)'] };

'use server';
// app/[...]/actions.ts
import { headers } from 'next/headers';
import { db } from '@/lib/db';
import { auth } from '@/lib/auth'; // your auth helper

export async function createProject(formData: FormData) {
  // Derive tenant from middleware header — never from form data
  const headerStore = await headers();
  const tenantSlug = headerStore.get('x-tenant-slug');
  if (!tenantSlug) throw new Error('Missing tenant context');

  const session = await auth();
  if (!session) throw new Error('Unauthenticated');

  const name = formData.get('name') as string;

  // Scope the insert to the resolved tenant
  const tenant = await db.tenant.findUniqueOrThrow({
    where: { slug: tenantSlug },
    select: { id: true },
  });

  return db.project.create({
    data: { name, tenantId: tenant.id, ownerId: session.user.id },
  });
}

// middleware.ts — dev query-param tenant override
import { NextRequest, NextResponse } from 'next/server';
import { resolveSubdomain } from './lib/tenant/resolveSubdomain';

const ROOT_DOMAIN = process.env.NEXT_PUBLIC_ROOT_DOMAIN ?? 'app.com';
const IS_DEV = process.env.NODE_ENV === 'development';

export function middleware(request: NextRequest) {
  const { hostname, searchParams } = request.nextUrl;

  let tenantSlug = resolveSubdomain(hostname, ROOT_DOMAIN);

  // Dev-only fallback: ?tenant=acme
  if (!tenantSlug && IS_DEV) {
    tenantSlug = searchParams.get('tenant');
  }

  if (!tenantSlug) return NextResponse.next();

  const requestHeaders = new Headers(request.headers);
  requestHeaders.set('x-tenant-slug', tenantSlug);

  return NextResponse.next({ request: { headers: requestHeaders } });
}

export const config = {
  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
};

// lib/tenant/url.ts
const ROOT_DOMAIN = process.env.NEXT_PUBLIC_ROOT_DOMAIN ?? 'app.com';
const STRATEGY = (process.env.NEXT_PUBLIC_TENANT_STRATEGY ?? 'subdomain') as
  | 'subdomain'
  | 'path';

/**
 * Build an absolute URL for a given tenant and path.
 * @param slug  - tenant slug, e.g. 'acme'
 * @param path  - app path, e.g. '/dashboard'
 */
export function tenantUrl(slug: string, path: string = '/'): string {
  const normalizedPath = path.startsWith('/') ? path : `/${path}`;

  if (STRATEGY === 'subdomain') {
    return `https://${slug}.${ROOT_DOMAIN}${normalizedPath}`;
  }

  // path-based: prepend slug as first segment
  return `https://${ROOT_DOMAIN}/${slug}${normalizedPath}`;
}

// Example usage:
// tenantUrl('acme', '/dashboard') => 'https://acme.app.com/dashboard'
// tenantUrl('acme', '/dashboard') => 'https://app.com/acme/dashboard'