Private Directory Platform

def normalize_phone(raw_phone: str | None) -> str | None:
    if not raw_phone:
        return None

    digits = re.sub(r"\D", "", raw_phone)
    if len(digits) == 11 and digits.startswith("1"):
        digits = digits[1:]

    return digits if len(digits) == 10 else None


def make_record_slug(name: str, city: str | None, region: str | None, used: set[str]) -> str:
    base = slugify(" ".join(part for part in [name, city or "", region or ""] if part))
    slug = base or "record"
    counter = 2

    while slug in used:
        slug = f"{base}-{counter}"
        counter += 1

    used.add(slug)
    return slug

export async function GET(request: NextRequest) {
    const rateLimit = await enforceRateLimits(request, publicApiRateLimitPolicies.directorySearch);
    if (!rateLimit.allowed) {
        return rateLimitExceededResponse(rateLimit);
    }

    const { searchParams } = new URL(request.url);
    const result = await searchDirectoryRecords({
        q: searchParams.get("q") ?? undefined,
        region: searchParams.get("region") ?? undefined,
        city: searchParams.get("city") ?? undefined,
        claimed: searchParams.get("claimed") === "true",
        features: searchParams.getAll("feature"),
        page: Number(searchParams.get("page") ?? 1),
        limit: Number(searchParams.get("limit") ?? 24),
    });

    return withRateLimitHeaders(
        NextResponse.json({ success: true, data: result }),
        rateLimit
    );
}

export async function uploadModeratedImage(params: UploadParams) {
    const validated = await validateImageFile(params.fileEntry);
    if (!validated) return null;

    const decision = params.user.role === "admin"
        ? null
        : moderateImageUpload({
            context: params.context,
            mimeType: validated.file.type,
            fileName: validated.file.name,
            fileSizeBytes: validated.fileSizeBytes,
            caption: params.caption ?? null,
        });

    const image = await uploadImageToCloudflare({
        file: validated.file,
        creatorUserId: params.user.id,
        metadata: { context: params.context, entityId: params.entityId },
    });

    return createMediaAsset({
        uploaderUserId: params.user.id,
        cloudflareImageId: image.id,
        imageUrl: getCloudflareDeliveryUrl(image.id, "public"),
        checksumSha256: validated.checksumSha256,
        moderationStatus: decision?.mediaStatus ?? "pending",
    });
}

function normalizeBounds(bounds: MapBounds): MapBounds {
    return {
        west: clamp(bounds.west, -180, 180),
        south: clamp(bounds.south, -90, 90),
        east: clamp(bounds.east, -180, 180),
        north: clamp(bounds.north, -90, 90),
    };
}

export async function GET(request: NextRequest) {
    const bounds = normalizeBounds(parseBounds(request.nextUrl.searchParams));
    const limit = clamp(Number(request.nextUrl.searchParams.get("limit") ?? 2000), 1, 2500);

    if (bounds.south >= bounds.north || bounds.west === bounds.east) {
        return NextResponse.json({ success: false, message: "Invalid map bounds." }, { status: 400 });
    }

    const markers = await getDirectoryMarkersInBounds(expandBounds(bounds), limit);
    return NextResponse.json({ success: true, data: { markers, limit } });
}