create-nextjs-cms 0.9.0 → 0.9.1

package/templates/default/app/api/trpc/[trpc]/route.ts

@@ -1,33 +1,33 @@
-import { fetchRequestHandler } from '@trpc/server/adapters/fetch'
-import { createTRPCContext, getAppRouter } from 'nextjs-cms/api'
-import { NextRequest } from 'next/server'
-
-/**
- * This wraps the `createContext` helper and provides the required context for the tRPC API when
- * handling a HTTP request (e.g. when you make requests from Client Components).
- */
-
-const context = async (req: NextRequest) => {
-    return createTRPCContext({
-        headers: req.headers,
-    })
-}
-
-const handler = async (req: NextRequest) =>
-    fetchRequestHandler({
-        endpoint: '/api/trpc',
-        req,
-        router: await getAppRouter(),
-        createContext: () => context(req),
-        /*onError(opts) {
-            return opts.error
-        },*/
-        onError:
-            process.env.NODE_ENV === 'development'
-                ? ({ path, error }) => {
-                      console.error(`❌ tRPC failed on ${path ?? '<no-path>'}: ${error.message}`)
-                  }
-                : undefined,
-    })
-
-export { handler as GET, handler as POST }
+import { fetchRequestHandler } from '@trpc/server/adapters/fetch'
+import { createTRPCContext, getAppRouter } from 'nextjs-cms/api'
+import { NextRequest } from 'next/server'
+
+/**
+ * This wraps the `createContext` helper and provides the required context for the tRPC API when
+ * handling a HTTP request (e.g. when you make requests from Client Components).
+ */
+
+const context = async (req: NextRequest) => {
+    return createTRPCContext({
+        headers: req.headers,
+    })
+}
+
+const handler = async (req: NextRequest) =>
+    fetchRequestHandler({
+        endpoint: '/api/trpc',
+        req,
+        router: await getAppRouter(),
+        createContext: () => context(req),
+        /*onError(opts) {
+            return opts.error
+        },*/
+        onError:
+            process.env.NODE_ENV === 'development'
+                ? ({ path, error }) => {
+                      console.error(`❌ tRPC failed on ${path ?? '<no-path>'}: ${error.message}`)
+                  }
+                : undefined,
+    })
+
+export { handler as GET, handler as POST }

package/templates/default/app/api/video/route.ts

@@ -1,174 +1,174 @@
-import { NextRequest, NextResponse } from 'next/server'
-import path from 'path'
-import fs from 'fs'
-import { readChunk } from 'read-chunk'
-import { fileTypeFromBuffer } from 'file-type'
-import { SectionFactory } from 'nextjs-cms/core/factories'
-import type { VideoField } from 'nextjs-cms/core/fields'
-import auth from 'nextjs-cms/auth'
-import { sanitizeFileName, sanitizeFolderOrFileName } from 'nextjs-cms/utils'
-import { streamFile } from 'nextjs-cms/api/helpers'
-import { getCMSConfig } from 'nextjs-cms/core/config'
-
-/**
- * This route handler is used to stream a video file from the server
- * It's used to protect the video files from being accessed directly
- * It's being used in the `<ProtectedVideo />` component
- * @param request
- * @constructor
- */
-
-export async function GET(request: NextRequest) {
-    const session = await auth()
-    const searchParams = request.nextUrl.searchParams
-
-    const name = searchParams.get('name')
-    const sectionName = searchParams.get('sectionName')
-    const fieldName = searchParams.get('fieldName')
-
-    if (!name || !sectionName || !fieldName) {
-        return NextResponse.json(
-            {
-                error: 'Invalid request',
-            },
-            { status: 400 },
-        )
-    }
-
-    // Check if the session is valid
-    if (!session || !session.user) {
-        return NextResponse.json(
-            {
-                error: 'Invalid token',
-            },
-            { status: 401 },
-        )
-    }
-
-    const uploadsFolder: string = (await getCMSConfig()).media.upload.path
-
-    // Sanitize the inputs
-    const sanitizedFolder = sanitizeFolderOrFileName(sectionName)
-    const sanitizedName = sanitizeFileName(name)
-    /**
-     * Check the section and the field name, and get the allowed extensions,
-     *  while also checking if the user has access to the section
-     */
-    const section = await SectionFactory.getSectionForAdmin({
-        name: sanitizedFolder,
-        admin: { id: session.user.id },
-    })
-
-    /**
-     * If the check fails, throw an error
-     */
-    if (!section || !section.name) {
-        return NextResponse.json(
-            {
-                error: 'File not found, or you do not have access to it.',
-            },
-            { status: 400 },
-        )
-    }
-
-    const fieldInfo = section.fields.find((field) => field.name === fieldName)?.build() as VideoField
-
-    /**
-     * If field is not found, throw an error
-     */
-    if (!fieldInfo || !fieldInfo.name || !fieldInfo.extensions || fieldInfo.extensions.length === 0) {
-        return NextResponse.json(
-            {
-                error: 'Invalid request',
-            },
-            { status: 400 },
-        )
-    }
-
-    /**
-     * Split the allowed extensions into an array
-     */
-    const videoAllowedExtensions = fieldInfo.extensions
-    const dir = '.videos'
-    const pathToFile = path.join(uploadsFolder, dir, sanitizedFolder, sanitizedName)
-    /**
-     * First, check if the file exists
-     */
-    if (!fs.existsSync(pathToFile)) {
-        return NextResponse.json(
-            {
-                error: 'File not found',
-            },
-            { status: 404 },
-        )
-    }
-
-    /**
-     * Read the first 4100 bytes of the file
-     */
-    const chunkBuffer = await readChunk(pathToFile, { length: 4100 })
-    /**
-     * Get the file type from the buffer
-     */
-    const fileType = await fileTypeFromBuffer(chunkBuffer)
-
-    /**
-     * If the file type is invalid, return an error
-     */
-    if (!fileType) {
-        return NextResponse.json(
-            {
-                error: 'Invalid file type',
-            },
-            { status: 400 },
-        )
-    }
-
-    /**
-     * Check if the file type is allowed
-     */
-    if (!videoAllowedExtensions.includes(fileType.ext)) {
-        return NextResponse.json(
-            {
-                error: 'Invalid file type',
-            },
-            { status: 400 },
-        )
-    }
-
-    const fileStats = fs.statSync(pathToFile)
-    const range = request.headers.get('range')
-    const videoSize = fileStats.size
-    const videoMimeType = fileType.mime
-
-    let res = null
-    if (range) {
-        const parts = range.replace(/bytes=/, '').split('-')
-        const start = parseInt(parts[0] ?? '0', 10)
-        const end = parts[1] ? parseInt(parts[1], 10) : videoSize - 1
-        const chunkSize = end - start + 1
-
-        const data: ReadableStream<Uint8Array> = await streamFile(pathToFile, { start, end })
-
-        res = new NextResponse(data, {
-            headers: {
-                'Content-Range': `bytes ${start}-${end}/${videoSize}`,
-                'Accept-Ranges': 'bytes',
-                'Content-Length': chunkSize.toString(),
-                'Content-Type': videoMimeType,
-            },
-            status: 206,
-        })
-    } else {
-        const data: ReadableStream<Uint8Array> = await streamFile(pathToFile)
-        res = new NextResponse(data, {
-            headers: {
-                'Content-Length': videoSize.toString(),
-                'Content-Type': videoMimeType,
-            },
-            status: 200,
-        })
-    }
-
-    return res
-}
+import { NextRequest, NextResponse } from 'next/server'
+import path from 'path'
+import fs from 'fs'
+import { readChunk } from 'read-chunk'
+import { fileTypeFromBuffer } from 'file-type'
+import { SectionFactory } from 'nextjs-cms/core/factories'
+import type { VideoField } from 'nextjs-cms/core/fields'
+import auth from 'nextjs-cms/auth'
+import { sanitizeFileName, sanitizeFolderOrFileName } from 'nextjs-cms/utils'
+import { streamFile } from 'nextjs-cms/api/helpers'
+import { getCMSConfig } from 'nextjs-cms/core/config'
+
+/**
+ * This route handler is used to stream a video file from the server
+ * It's used to protect the video files from being accessed directly
+ * It's being used in the `<ProtectedVideo />` component
+ * @param request
+ * @constructor
+ */
+
+export async function GET(request: NextRequest) {
+    const session = await auth()
+    const searchParams = request.nextUrl.searchParams
+
+    const name = searchParams.get('name')
+    const sectionName = searchParams.get('sectionName')
+    const fieldName = searchParams.get('fieldName')
+
+    if (!name || !sectionName || !fieldName) {
+        return NextResponse.json(
+            {
+                error: 'Invalid request',
+            },
+            { status: 400 },
+        )
+    }
+
+    // Check if the session is valid
+    if (!session || !session.user) {
+        return NextResponse.json(
+            {
+                error: 'Invalid token',
+            },
+            { status: 401 },
+        )
+    }
+
+    const uploadsFolder: string = (await getCMSConfig()).media.upload.path
+
+    // Sanitize the inputs
+    const sanitizedFolder = sanitizeFolderOrFileName(sectionName)
+    const sanitizedName = sanitizeFileName(name)
+    /**
+     * Check the section and the field name, and get the allowed extensions,
+     *  while also checking if the user has access to the section
+     */
+    const section = await SectionFactory.getSectionForAdmin({
+        name: sanitizedFolder,
+        admin: { id: session.user.id },
+    })
+
+    /**
+     * If the check fails, throw an error
+     */
+    if (!section || !section.name) {
+        return NextResponse.json(
+            {
+                error: 'File not found, or you do not have access to it.',
+            },
+            { status: 400 },
+        )
+    }
+
+    const fieldInfo = section.fields.find((field) => field.name === fieldName)?.build() as VideoField
+
+    /**
+     * If field is not found, throw an error
+     */
+    if (!fieldInfo || !fieldInfo.name || !fieldInfo.extensions || fieldInfo.extensions.length === 0) {
+        return NextResponse.json(
+            {
+                error: 'Invalid request',
+            },
+            { status: 400 },
+        )
+    }
+
+    /**
+     * Split the allowed extensions into an array
+     */
+    const videoAllowedExtensions = fieldInfo.extensions
+    const dir = '.videos'
+    const pathToFile = path.join(uploadsFolder, dir, sanitizedFolder, sanitizedName)
+    /**
+     * First, check if the file exists
+     */
+    if (!fs.existsSync(pathToFile)) {
+        return NextResponse.json(
+            {
+                error: 'File not found',
+            },
+            { status: 404 },
+        )
+    }
+
+    /**
+     * Read the first 4100 bytes of the file
+     */
+    const chunkBuffer = await readChunk(pathToFile, { length: 4100 })
+    /**
+     * Get the file type from the buffer
+     */
+    const fileType = await fileTypeFromBuffer(chunkBuffer)
+
+    /**
+     * If the file type is invalid, return an error
+     */
+    if (!fileType) {
+        return NextResponse.json(
+            {
+                error: 'Invalid file type',
+            },
+            { status: 400 },
+        )
+    }
+
+    /**
+     * Check if the file type is allowed
+     */
+    if (!videoAllowedExtensions.includes(fileType.ext)) {
+        return NextResponse.json(
+            {
+                error: 'Invalid file type',
+            },
+            { status: 400 },
+        )
+    }
+
+    const fileStats = fs.statSync(pathToFile)
+    const range = request.headers.get('range')
+    const videoSize = fileStats.size
+    const videoMimeType = fileType.mime
+
+    let res = null
+    if (range) {
+        const parts = range.replace(/bytes=/, '').split('-')
+        const start = parseInt(parts[0] ?? '0', 10)
+        const end = parts[1] ? parseInt(parts[1], 10) : videoSize - 1
+        const chunkSize = end - start + 1
+
+        const data: ReadableStream<Uint8Array> = await streamFile(pathToFile, { start, end })
+
+        res = new NextResponse(data, {
+            headers: {
+                'Content-Range': `bytes ${start}-${end}/${videoSize}`,
+                'Accept-Ranges': 'bytes',
+                'Content-Length': chunkSize.toString(),
+                'Content-Type': videoMimeType,
+            },
+            status: 206,
+        })
+    } else {
+        const data: ReadableStream<Uint8Array> = await streamFile(pathToFile)
+        res = new NextResponse(data, {
+            headers: {
+                'Content-Length': videoSize.toString(),
+                'Content-Type': videoMimeType,
+            },
+            status: 200,
+        })
+    }
+
+    return res
+}