nextly 0.0.1 → 0.0.2-alpha.0

package/dist/api/media-folders.mjs

@@ -0,0 +1,187 @@
+import {
+  readJsonBody
+} from "../chunk-VQJQHVEV.mjs";
+import "../chunk-VWF3JO32.mjs";
+import {
+  withErrorHandler
+} from "../chunk-TO5AFLVQ.mjs";
+import {
+  getCachedNextly
+} from "../chunk-P7NH2OSC.mjs";
+import "../chunk-2OALJTK6.mjs";
+import "../chunk-VJ66NCL4.mjs";
+import "../chunk-R6JJQHFC.mjs";
+import "../chunk-X23WKS3Z.mjs";
+import {
+  getService
+} from "../chunk-X7TXCYYN.mjs";
+import "../chunk-YZNBLFIW.mjs";
+import "../chunk-FQULBZ53.mjs";
+import "../chunk-67GXH6PR.mjs";
+import "../chunk-2TFX4ND3.mjs";
+import "../chunk-W4MGXIRR.mjs";
+import "../chunk-NSEFNNU4.mjs";
+import "../chunk-3FA7FKAV.mjs";
+import "../chunk-AGJ6F2T3.mjs";
+import "../chunk-KIMNCZGV.mjs";
+import "../chunk-AK6Z23OX.mjs";
+import "../chunk-INV7QKLG.mjs";
+import "../chunk-GZ6DCQKC.mjs";
+import "../chunk-SBACDPNX.mjs";
+import "../chunk-RJLLGGPG.mjs";
+import "../chunk-V4EQTOA4.mjs";
+import "../chunk-I4JMR3UR.mjs";
+import "../chunk-XZKLBMN6.mjs";
+import "../chunk-IZWPRDC3.mjs";
+import "../chunk-DNNG377Z.mjs";
+import "../chunk-5HMZ644B.mjs";
+import "../chunk-W5KKPZT5.mjs";
+import "../chunk-56WO4WX7.mjs";
+import "../chunk-2W3DVD7S.mjs";
+import "../chunk-TS7GHTG2.mjs";
+import "../chunk-H26B4FYG.mjs";
+import "../chunk-DP3G27G5.mjs";
+import "../chunk-DV6WVX2Q.mjs";
+import "../chunk-UJ2IMJ4W.mjs";
+import "../chunk-EGXBZCGC.mjs";
+import "../chunk-G2AA4QLC.mjs";
+import "../chunk-4MJLT6PZ.mjs";
+import {
+  respondAction,
+  respondData,
+  respondDoc,
+  respondMutation
+} from "../chunk-IUDOC7N7.mjs";
+import "../chunk-LAZXX4HR.mjs";
+import "../chunk-D5HQBNUB.mjs";
+import {
+  NextlyError
+} from "../chunk-NRUWQ5Z7.mjs";
+import "../chunk-VTJADRO3.mjs";
+import "../chunk-5APFUGAD.mjs";
+import "../chunk-7P6ASYW6.mjs";
+
+// src/api/media-folders.ts
+async function getMediaService() {
+  await getCachedNextly();
+  return getService("mediaService");
+}
+function createRequestContext() {
+  return {};
+}
+function createAuthenticatedContext(userId) {
+  return {
+    user: {
+      id: userId,
+      email: `${userId}@api.local`,
+      role: "user",
+      permissions: []
+    }
+  };
+}
+var GET = withErrorHandler(
+  async (request) => {
+    const mediaService = await getMediaService();
+    const context = createRequestContext();
+    const { searchParams } = new URL(request.url);
+    const root = searchParams.get("root") === "true";
+    const parentId = searchParams.get("parentId");
+    const folders = root || !parentId ? await mediaService.listRootFolders(context) : await mediaService.listSubfolders(parentId, context);
+    return respondData({ folders });
+  }
+);
+var POST = withErrorHandler(
+  async (request) => {
+    const mediaService = await getMediaService();
+    const body = await readJsonBody(request);
+    const { createdBy, ...folderInput } = body;
+    const errors = [];
+    if (!createdBy) {
+      errors.push({
+        path: "createdBy",
+        code: "REQUIRED",
+        message: "createdBy is required."
+      });
+    }
+    if (!folderInput.name) {
+      errors.push({
+        path: "name",
+        code: "REQUIRED",
+        message: "name is required."
+      });
+    }
+    if (errors.length > 0) {
+      throw NextlyError.validation({ errors });
+    }
+    const context = createAuthenticatedContext(createdBy);
+    const folder = await mediaService.createFolder(
+      folderInput,
+      context
+    );
+    return respondMutation("Folder created.", folder, { status: 201 });
+  }
+);
+function getFolderById(request, routeContext) {
+  return withErrorHandler(
+    async (_req, ctx) => {
+      const mediaService = await getMediaService();
+      const params = await ctx.params;
+      const context = createRequestContext();
+      const folder = await mediaService.findFolderById(params.id, context);
+      return respondDoc(folder);
+    }
+  )(request, routeContext);
+}
+function updateFolder(request, routeContext) {
+  return withErrorHandler(
+    async (req, ctx) => {
+      const mediaService = await getMediaService();
+      const params = await ctx.params;
+      const body = await readJsonBody(req);
+      const context = createRequestContext();
+      const folder = await mediaService.updateFolder(params.id, body, context);
+      return respondMutation("Folder updated.", folder);
+    }
+  )(request, routeContext);
+}
+function deleteFolder(request, routeContext) {
+  return withErrorHandler(
+    async (req, ctx) => {
+      const mediaService = await getMediaService();
+      const params = await ctx.params;
+      const context = createRequestContext();
+      const { searchParams } = new URL(req.url);
+      const deleteContents = searchParams.get("deleteContents") === "true";
+      await mediaService.deleteFolder(params.id, deleteContents, context);
+      return respondAction("Folder deleted.", { id: params.id });
+    }
+  )(request, routeContext);
+}
+function getFolderContents(request, routeContext) {
+  return withErrorHandler(
+    async (_req, ctx) => {
+      const mediaService = await getMediaService();
+      const params = await ctx.params;
+      const context = createRequestContext();
+      const contents = await mediaService.getFolderContents(params.id, context);
+      return respondData(contents);
+    }
+  )(request, routeContext);
+}
+var getRootFolderContents = withErrorHandler(
+  async (_request) => {
+    const mediaService = await getMediaService();
+    const context = createRequestContext();
+    const contents = await mediaService.getFolderContents(null, context);
+    return respondData(contents);
+  }
+);
+export {
+  GET,
+  POST,
+  deleteFolder,
+  getFolderById,
+  getFolderContents,
+  getRootFolderContents,
+  updateFolder
+};

package/dist/api/media-handlers.d.ts

@@ -0,0 +1,102 @@
+import { S as SanitizedNextlyConfig } from '../_dts-chunks/config.d-DNwsDnjs.d.ts';
+import '../_dts-chunks/collections-handler.d-DjgO74Wt.d.ts';
+import '@nextlyhq/adapter-drizzle';
+import '@nextlyhq/adapter-drizzle/types';
+import 'drizzle-orm/pg-core';
+import 'react';
+import '../_dts-chunks/media.d-DjDOZo4B.d.ts';
+import 'zod';
+import '../_dts-chunks/image-processor.d-OO1PmMrv.d.ts';
+import 'drizzle-orm';
+import '../_dts-chunks/storage.d-BUhQ2we_.d.ts';
+
+/**
+ * Dynamic Media Route Handler
+ *
+ * Creates HTTP method handlers for Next.js media API routes using a catch-all pattern.
+ * This provides a single handler that routes all media operations (files, folders).
+ *
+ * Uses a single catch-all route to handle all media-related endpoints,
+ * simplifying the consumer's route structure.
+ *
+ * **IMPORTANT:** For storage plugins (S3, Vercel Blob, etc.) to work, you must
+ * initialize Nextly with your config before these routes are called. The recommended
+ * approach is to use Next.js instrumentation:
+ *
+ * ```typescript
+ * // src/instrumentation.ts
+ * export async function register() {
+ *   if (process.env.NEXT_RUNTIME === "nodejs") {
+ *     const { getNextly } = await import("nextly");
+ *     const nextlyConfig = (await import("./nextly.config")).default;
+ *     await getNextly({ config: nextlyConfig });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In your Next.js app: app/api/media/[[...path]]/route.ts
+ * import { createMediaHandlers } from 'nextly/api/media-handlers';
+ *
+ * const handlers = createMediaHandlers();
+ * export const GET = handlers.GET;
+ * export const POST = handlers.POST;
+ * export const PATCH = handlers.PATCH;
+ * export const DELETE = handlers.DELETE;
+ * ```
+ *
+ * Supported Routes:
+ * - GET    /api/media                        - List media with pagination
+ * - POST   /api/media                        - Upload new media file
+ * - GET    /api/media/:id                    - Get media by ID
+ * - PATCH  /api/media/:id                    - Update media metadata
+ * - DELETE /api/media/:id                    - Delete media file
+ * - PATCH  /api/media/:id/move               - Move media to folder
+ * - GET    /api/media/folders                - List folders
+ * - POST   /api/media/folders                - Create folder
+ * - GET    /api/media/folders/:id            - Get folder by ID
+ * - PATCH  /api/media/folders/:id            - Update folder
+ * - DELETE /api/media/folders/:id            - Delete folder
+ * - GET    /api/media/folders/:id/contents   - Get folder contents
+ * - GET    /api/media/folders/root/contents  - Get root folder contents
+ *
+ * @module api/media-handlers
+ */
+
+/**
+ * Route context for Next.js App Router dynamic routes.
+ */
+interface RouteContext {
+    params: Promise<{
+        path?: string[];
+    }>;
+}
+/**
+ * Options for creating media handlers.
+ */
+interface MediaHandlerOptions {
+    /**
+     * Nextly configuration object.
+     * Pass this to ensure storage plugins are available even if
+     * instrumentation hasn't run in this worker process.
+     */
+    config?: SanitizedNextlyConfig;
+}
+/**
+ * Create dynamic HTTP method handlers for Next.js media API routes
+ *
+ * Use with a catch-all route pattern: app/api/media/[[...path]]/route.ts
+ *
+ * @param options - Optional configuration including nextly config
+ * @returns Object with handlers for GET, POST, PATCH, DELETE
+ */
+declare function createMediaHandlers(options?: MediaHandlerOptions): {
+    GET: (request: Request, ctx: RouteContext) => Promise<Response>;
+    POST: (request: Request, ctx: RouteContext) => Promise<Response>;
+    PATCH: (request: Request, ctx: RouteContext) => Promise<Response>;
+    DELETE: (request: Request, ctx: RouteContext) => Promise<Response>;
+};
+
+export { createMediaHandlers };
+export type { MediaHandlerOptions, RouteContext };