betterstart-cli 0.0.1

package/dist/assets/adapters/next/templates/init/lib/actions/storage/local.ts

@@ -0,0 +1,31 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type {
+  AdminStorageProvider,
+  AdminStorageUploadInput,
+  AdminStorageUploadResult
+} from '@admin/actions/storage/types'
+import { buildLocalStorageKey } from '@admin/utils/storage/local'
+
+async function saveLocally({
+  buffer,
+  filename,
+  prefix
+}: AdminStorageUploadInput): Promise<AdminStorageUploadResult> {
+  const key = buildLocalStorageKey(filename, prefix)
+  const outputPath = path.join(process.cwd(), 'public', key)
+
+  await mkdir(path.dirname(outputPath), { recursive: true })
+  await writeFile(outputPath, buffer)
+
+  return {
+    key,
+    url: `/${key}`
+  }
+}
+
+export const localStorageProvider: AdminStorageProvider = {
+  id: 'local',
+  isConfigured: () => true,
+  saveFile: saveLocally
+}

package/dist/assets/adapters/next/templates/init/lib/actions/storage/provider.ts

@@ -0,0 +1,6 @@
+import { localStorageProvider } from '@admin/actions/storage/local'
+import type { AdminStorageProvider } from '@admin/actions/storage/types'
+
+export function getStorageProvider(): AdminStorageProvider {
+  return localStorageProvider
+}

package/dist/assets/adapters/next/templates/init/lib/actions/storage/save-upload.ts

@@ -0,0 +1,11 @@
+import type {
+  AdminStorageUploadInput,
+  AdminStorageUploadResult
+} from '@admin/actions/storage/types'
+import { getStorageProvider } from './provider'
+
+export async function saveUpload(
+  input: AdminStorageUploadInput
+): Promise<AdminStorageUploadResult> {
+  return getStorageProvider().saveFile(input)
+}

package/dist/assets/adapters/next/templates/init/lib/actions/storage/types.ts

@@ -0,0 +1,18 @@
+export interface AdminStorageUploadInput {
+  buffer: Buffer
+  filename: string
+  contentType: string
+  prefix?: string
+  contentLength?: number
+}
+
+export interface AdminStorageUploadResult {
+  key: string
+  url: string
+}
+
+export interface AdminStorageProvider {
+  id: string
+  isConfigured: () => boolean
+  saveFile: (input: AdminStorageUploadInput) => Promise<AdminStorageUploadResult>
+}

package/dist/assets/adapters/next/templates/init/lib/actions/upload/index.ts

@@ -0,0 +1,9 @@
+export type {
+  FileValidationConfig,
+  RemoteUploadOptions,
+  UploadResult
+} from './types'
+export { uploadFile } from './upload-file'
+export { uploadFiles } from './upload-files'
+export { uploadImageFromUrl } from './upload-image-from-url'
+export { uploadMediaFromUrl } from './upload-media-from-url'

package/dist/assets/adapters/next/templates/init/lib/actions/upload/types.ts

@@ -0,0 +1,17 @@
+export interface UploadResult {
+  success: boolean
+  files?: import('@admin/types').UploadedFile[]
+  error?: string
+}
+
+export interface FileValidationConfig {
+  maxFiles?: number
+  maxSizeInBytes?: number
+  allowedTypes?: string[]
+}
+
+export interface RemoteUploadOptions {
+  prefix?: string
+  accept?: string
+  maxSizeInBytes?: number
+}

package/dist/assets/adapters/next/templates/init/lib/actions/upload/upload-file.ts

@@ -0,0 +1,11 @@
+'use server'
+
+import type { FileValidationConfig, UploadResult } from './types'
+import { uploadFiles } from './upload-files'
+
+export async function uploadFile(
+  formData: FormData,
+  config: FileValidationConfig = {}
+): Promise<UploadResult> {
+  return uploadFiles(formData, { ...config, maxFiles: 1 })
+}

package/dist/assets/adapters/next/templates/init/lib/actions/upload/upload-files.ts

@@ -0,0 +1,92 @@
+'use server'
+
+import { createMedia } from '@admin/actions/media'
+import { saveUpload } from '@admin/actions/storage'
+import type { UploadedFile } from '@admin/types'
+import type { FileValidationConfig, UploadResult } from './types'
+
+export async function uploadFiles(
+  formData: FormData,
+  config: FileValidationConfig = {}
+): Promise<UploadResult> {
+  try {
+    const files: File[] = []
+    const prefix = formData.get('prefix')?.toString() || 'uploads'
+
+    for (const [key, value] of formData.entries()) {
+      if (value instanceof File && key.startsWith('file')) {
+        files.push(value)
+      }
+    }
+
+    if (files.length === 0) {
+      return { success: false, error: 'No files provided' }
+    }
+
+    if (config.maxFiles && files.length > config.maxFiles) {
+      return {
+        success: false,
+        error: `Too many files. Maximum is ${config.maxFiles}`
+      }
+    }
+
+    const uploadedFiles: UploadedFile[] = []
+
+    for (const file of files) {
+      if (config.maxSizeInBytes && file.size > config.maxSizeInBytes) {
+        return {
+          success: false,
+          error: `File ${file.name} exceeds size limit`
+        }
+      }
+      if (config.allowedTypes && !config.allowedTypes.includes(file.type)) {
+        return {
+          success: false,
+          error: `File type ${file.type} is not allowed`
+        }
+      }
+
+      const arrayBuffer = await file.arrayBuffer()
+      const buffer = Buffer.from(arrayBuffer)
+      const { key, url } = await saveUpload({
+        buffer,
+        filename: file.name,
+        contentType: file.type,
+        contentLength: file.size,
+        prefix
+      })
+
+      const mediaResult = await createMedia({
+        url,
+        filename: file.name,
+        contentType: file.type,
+        size: file.size,
+        width: null,
+        height: null,
+        alt: null,
+        tags: null
+      })
+
+      if (!mediaResult.success || !mediaResult.media) {
+        return {
+          success: false,
+          error: mediaResult.error ?? 'Failed to create media record'
+        }
+      }
+
+      uploadedFiles.push({
+        id: mediaResult.media.id,
+        key,
+        url,
+        filename: file.name,
+        size: file.size,
+        contentType: file.type
+      })
+    }
+
+    return { success: true, files: uploadedFiles }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to upload files'
+    return { success: false, error: message }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/upload/upload-image-from-url.ts

@@ -0,0 +1,22 @@
+'use server'
+
+import { uploadMediaFromUrl } from './upload-media-from-url'
+
+export async function uploadImageFromUrl(
+  imageUrl: string,
+  prefix = 'images'
+): Promise<{ success: boolean; url?: string; error?: string }> {
+  const result = await uploadMediaFromUrl(imageUrl, {
+    prefix,
+    accept: 'image/*'
+  })
+
+  if (!result.success || !result.files?.[0]) {
+    return {
+      success: false,
+      error: result.error ?? 'Failed to upload image from URL'
+    }
+  }
+
+  return { success: true, url: result.files[0].url }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/upload/upload-media-from-url.ts

@@ -0,0 +1,133 @@
+'use server'
+
+import { createMedia } from '@admin/actions/media'
+import { saveUpload } from '@admin/actions/storage'
+import {
+  DEFAULT_REMOTE_ACCEPT,
+  getRemoteFilename,
+  isAcceptedRemoteType,
+  REMOTE_FETCH_TIMEOUT_MS
+} from '@admin/utils/upload/remote'
+import type { RemoteUploadOptions, UploadResult } from './types'
+
+export async function uploadMediaFromUrl(
+  mediaUrl: string,
+  { prefix = 'media', accept = DEFAULT_REMOTE_ACCEPT, maxSizeInBytes }: RemoteUploadOptions = {}
+): Promise<UploadResult> {
+  try {
+    const url = new URL(mediaUrl)
+    if (!['http:', 'https:'].includes(url.protocol)) {
+      return { success: false, error: 'Only HTTP and HTTPS URLs are allowed' }
+    }
+
+    const response = await fetch(mediaUrl, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (compatible; BetterStartMediaFetcher/1.0)'
+      },
+      signal: AbortSignal.timeout(REMOTE_FETCH_TIMEOUT_MS)
+    })
+
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `Failed to fetch media: ${response.status}`
+      }
+    }
+
+    const contentType = (response.headers.get('content-type') || 'application/octet-stream')
+      .split(';')[0]
+      .trim()
+      .toLowerCase()
+
+    if (!contentType.startsWith('image/') && !contentType.startsWith('video/')) {
+      return { success: false, error: `Invalid content type: ${contentType}` }
+    }
+
+    const filename = getRemoteFilename(url, contentType)
+
+    if (!isAcceptedRemoteType(contentType, filename, accept)) {
+      return {
+        success: false,
+        error: 'The remote file type is not allowed for this uploader'
+      }
+    }
+
+    const contentLength = Number(response.headers.get('content-length') ?? 0)
+
+    if (
+      typeof maxSizeInBytes === 'number' &&
+      maxSizeInBytes > 0 &&
+      Number.isFinite(contentLength) &&
+      contentLength > maxSizeInBytes
+    ) {
+      const maxSizeInMb = Math.round(maxSizeInBytes / (1024 * 1024))
+      return {
+        success: false,
+        error: `Remote file exceeds ${maxSizeInMb}MB limit`
+      }
+    }
+
+    const arrayBuffer = await response.arrayBuffer()
+    const buffer = Buffer.from(arrayBuffer)
+
+    if (buffer.length === 0) return { success: false, error: 'Remote file is empty' }
+    if (
+      typeof maxSizeInBytes === 'number' &&
+      maxSizeInBytes > 0 &&
+      buffer.length > maxSizeInBytes
+    ) {
+      const maxSizeInMb = Math.round(maxSizeInBytes / (1024 * 1024))
+      return {
+        success: false,
+        error: `Remote file exceeds ${maxSizeInMb}MB limit`
+      }
+    }
+
+    const { key, url: uploadedUrl } = await saveUpload({
+      buffer,
+      filename,
+      contentType,
+      contentLength: buffer.length,
+      prefix
+    })
+
+    const mediaResult = await createMedia({
+      url: uploadedUrl,
+      filename,
+      contentType,
+      size: buffer.length,
+      width: null,
+      height: null,
+      alt: null,
+      tags: null
+    })
+
+    if (!mediaResult.success || !mediaResult.media) {
+      return {
+        success: false,
+        error: mediaResult.error ?? 'Failed to create media record'
+      }
+    }
+
+    return {
+      success: true,
+      files: [
+        {
+          id: mediaResult.media.id,
+          key,
+          url: uploadedUrl,
+          filename,
+          size: buffer.length,
+          contentType,
+          width: mediaResult.media.width,
+          height: mediaResult.media.height,
+          alt: mediaResult.media.alt,
+          tags: mediaResult.media.tags ?? undefined
+        }
+      ]
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to upload media from URL'
+    return { success: false, error: message }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/users/create-user.ts

@@ -0,0 +1,55 @@
+'use server'
+
+import { auth } from '@admin/auth'
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { user } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { CreateUserInput, CreateUserResult } from './types'
+import { usersCacheTags } from './types'
+
+export async function createUser(input: CreateUserInput): Promise<CreateUserResult> {
+  await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    const result = await auth.api.signUpEmail({
+      body: {
+        email: input.email,
+        password: input.password,
+        name: input.name
+      }
+    })
+
+    if (!result?.user) {
+      return { success: false, error: 'Failed to create user' }
+    }
+
+    await db
+      .update(user)
+      .set({
+        role: input.role,
+        updatedAt: new Date()
+      })
+      .where(eq(user.id, result.user.id))
+    updateTag(usersCacheTags.all)
+
+    return {
+      success: true,
+      user: {
+        id: result.user.id,
+        email: result.user.email,
+        name: input.name,
+        emailVerified: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        role: input.role
+      }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to create user'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/users/delete-user.ts

@@ -0,0 +1,24 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { user } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { DeleteUserResult } from './types'
+import { usersCacheTags } from './types'
+
+export async function deleteUser(userId: string): Promise<DeleteUserResult> {
+  await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    await db.delete(user).where(eq(user.id, userId))
+    updateTag(usersCacheTags.all)
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to delete user'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/actions/users/get-users.ts

@@ -0,0 +1,49 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { user } from '@admin/db/schema'
+import { cacheLife, cacheTag } from 'next/cache'
+import type { User, UsersPage } from './types'
+import { usersCacheTags } from './types'
+
+async function getCachedUsers(): Promise<UsersPage> {
+  'use cache'
+  cacheLife('max')
+  cacheTag(usersCacheTags.all)
+
+  try {
+    const users = await db
+      .select({
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        emailVerified: user.emailVerified,
+        createdAt: user.createdAt,
+        updatedAt: user.updatedAt,
+        role: user.role
+      })
+      .from(user)
+      .orderBy(user.createdAt)
+
+    const userData: User[] = users.map((u) => ({
+      id: u.id,
+      email: u.email,
+      name: u.name,
+      emailVerified: u.emailVerified,
+      createdAt: u.createdAt.toISOString(),
+      updatedAt: u.updatedAt.toISOString(),
+      role: u.role || 'member'
+    }))
+
+    return { users: userData, total: userData.length }
+  } catch {
+    return { users: [], total: 0 }
+  }
+}
+
+export async function getUsers(): Promise<UsersPage> {
+  await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  return getCachedUsers()
+}

package/dist/assets/adapters/next/templates/init/lib/actions/users/index.ts

@@ -0,0 +1,12 @@
+export { createUser } from './create-user'
+export { deleteUser } from './delete-user'
+export { getUsers } from './get-users'
+export type {
+  CreateUserInput,
+  CreateUserResult,
+  DeleteUserResult,
+  UpdateUserRoleResult,
+  User,
+  UsersPage
+} from './types'
+export { updateUserRole } from './update-user-role'

package/dist/assets/adapters/next/templates/init/lib/actions/users/types.ts

@@ -0,0 +1,43 @@
+import type { UserRole } from '@admin/types/auth'
+
+export interface User {
+  id: string
+  email: string
+  name: string
+  emailVerified: boolean
+  createdAt: string
+  updatedAt: string
+  role: string
+}
+
+export interface UsersPage {
+  users: User[]
+  total: number
+}
+
+export interface CreateUserInput {
+  email: string
+  name: string
+  password: string
+  role: UserRole
+}
+
+export interface CreateUserResult {
+  success: boolean
+  error?: string
+  user?: User
+}
+
+export interface UpdateUserRoleResult {
+  success: boolean
+  error?: string
+}
+
+export interface DeleteUserResult {
+  success: boolean
+  error?: string
+}
+
+export const usersCacheTags = {
+  all: 'users:all'
+} as const

package/dist/assets/adapters/next/templates/init/lib/actions/users/update-user-role.ts

@@ -0,0 +1,28 @@
+'use server'
+
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import db from '@admin/db'
+import { user } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { updateTag } from 'next/cache'
+import type { UpdateUserRoleResult } from './types'
+import { usersCacheTags } from './types'
+
+export async function updateUserRole(
+  userId: string,
+  role: UserRole
+): Promise<UpdateUserRoleResult> {
+  await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    await db.update(user).set({ role, updatedAt: new Date() }).where(eq(user.id, userId))
+    updateTag(usersCacheTags.all)
+
+    return { success: true }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to update user role'
+    }
+  }
+}

package/dist/assets/adapters/next/templates/init/lib/db/client.ts

@@ -0,0 +1,13 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+import * as schema from './schema'
+
+const databaseUrl = process.env.DATABASE_URL
+if (!databaseUrl) {
+  throw new Error('DATABASE_URL is required')
+}
+
+const client = postgres(databaseUrl)
+const db = drizzle({ client, schema })
+
+export default db