canopycms 0.0.0 → 0.0.2

package/src/user.ts

@@ -1,118 +0,0 @@
-import type { CanopyUserId, CanopyGroupId } from './types'
-import type { AuthenticationResult } from './auth/types'
-// Import from client-safe subpaths to avoid pulling in server-only loader code
-import { RESERVED_GROUPS } from './authorization/helpers'
-import type { InternalGroup } from './authorization/groups/schema'
-
-/**
- * Anonymous user - explicitly marked for public/unauthenticated access
- */
-export interface AnonymousUser {
-  type: 'anonymous'
-  userId: 'anonymous'
-  groups: readonly []
-}
-
-/**
- * Authenticated user - verified identity from auth provider
- */
-export interface AuthenticatedUser {
-  type: 'authenticated'
-  userId: CanopyUserId
-  groups: CanopyGroupId[]
-  email?: string
-  name?: string
-  avatarUrl?: string
-}
-
-/**
- * Unified user type for all CanopyCMS operations
- */
-export type CanopyUser = AnonymousUser | AuthenticatedUser
-
-/**
- * Branded ANONYMOUS_USER constant - use this for intentional anonymous access.
- * Callers must explicitly pass this to indicate anonymous access is intended.
- */
-export const ANONYMOUS_USER: AnonymousUser = Object.freeze({
-  type: 'anonymous',
-  userId: 'anonymous',
-  groups: [] as const,
-}) as AnonymousUser
-
-/**
- * Type guard for anonymous user
- */
-export const isAnonymousUser = (user: CanopyUser): user is AnonymousUser =>
-  user.type === 'anonymous'
-
-/**
- * Type guard for authenticated user
- */
-export const isAuthenticatedUser = (user: CanopyUser): user is AuthenticatedUser =>
-  user.type === 'authenticated'
-
-/**
- * Create an authenticated user from auth provider data
- */
-export const createAuthenticatedUser = (data: {
-  userId: CanopyUserId
-  groups?: CanopyGroupId[]
-  email?: string
-  name?: string
-  avatarUrl?: string
-}): AuthenticatedUser => ({
-  type: 'authenticated',
-  userId: data.userId,
-  groups: data.groups ?? [],
-  email: data.email,
-  name: data.name,
-  avatarUrl: data.avatarUrl,
-})
-
-/**
- * Convert authentication result to CanopyUser.
- * Applies bootstrap admin groups, merges internal groups, and returns ANONYMOUS_USER if not authenticated.
- *
- * This is the SINGLE source of truth for converting external auth to CanopyUser.
- *
- * @param authResult - Result from auth plugin's authenticate() method
- * @param bootstrapAdminIds - Set of user IDs that should always be admins
- * @param internalGroups - Optional internal groups from .canopycms/groups.json (loaded by caller)
- * @returns CanopyUser (either authenticated with groups or ANONYMOUS_USER)
- */
-export function authResultToCanopyUser(
-  authResult: AuthenticationResult,
-  bootstrapAdminIds: Set<string>,
-  internalGroups?: InternalGroup[],
-): CanopyUser {
-  if (!authResult.success || !authResult.user) {
-    return ANONYMOUS_USER
-  }
-
-  // Step 1: Start with external groups from auth provider
-  const groups = [...(authResult.user.externalGroups ?? [])]
-
-  // Step 2: Add Admins group if user is in bootstrap admin list
-  if (bootstrapAdminIds.has(authResult.user.userId) && !groups.includes(RESERVED_GROUPS.ADMINS)) {
-    groups.push(RESERVED_GROUPS.ADMINS)
-  }
-
-  // Step 3: Merge internal groups from .canopycms/groups.json
-  if (internalGroups) {
-    for (const group of internalGroups) {
-      if (group.members.includes(authResult.user.userId) && !groups.includes(group.id)) {
-        groups.push(group.id)
-      }
-    }
-  }
-
-  return {
-    type: 'authenticated',
-    userId: authResult.user.userId,
-    email: authResult.user.email,
-    name: authResult.user.name,
-    avatarUrl: authResult.user.avatarUrl,
-    groups,
-  }
-}

package/src/utils/debug.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { createDebugLogger } from './debug'
-
-describe('DebugLogger', () => {
-  let originalEnv: string | undefined
-
-  beforeEach(() => {
-    // Save original env var
-    originalEnv = process.env.CANOPYCMS_DEBUG
-    // Mock console methods
-    vi.spyOn(console, 'log').mockImplementation(() => {})
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-    vi.spyOn(console, 'error').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    // Restore env var
-    if (originalEnv === undefined) {
-      delete process.env.CANOPYCMS_DEBUG
-    } else {
-      process.env.CANOPYCMS_DEBUG = originalEnv
-    }
-    vi.restoreAllMocks()
-  })
-
-  it('respects enabled option', () => {
-    const logger = createDebugLogger({ enabled: true })
-    logger.debug('test', 'message')
-
-    expect(console.log).toHaveBeenCalledOnce()
-  })
-
-  it('respects disabled option', () => {
-    const logger = createDebugLogger({ enabled: false })
-    logger.debug('test', 'message')
-
-    expect(console.log).not.toHaveBeenCalled()
-  })
-
-  it('checks CANOPYCMS_DEBUG env var at call time, not construction time', () => {
-    // Create logger before env var is set
-    const logger = createDebugLogger()
-
-    // Initially disabled
-    logger.debug('test', 'message 1')
-    expect(console.log).not.toHaveBeenCalled()
-
-    // Enable via env var AFTER logger was created
-    process.env.CANOPYCMS_DEBUG = 'true'
-
-    // Should now be enabled
-    logger.debug('test', 'message 2')
-    expect(console.log).toHaveBeenCalledOnce()
-
-    // Disable again
-    process.env.CANOPYCMS_DEBUG = 'false'
-
-    // Should be disabled
-    logger.debug('test', 'message 3')
-    expect(console.log).toHaveBeenCalledOnce() // Still only called once
-  })
-
-  it('explicit enabled option overrides env var', () => {
-    process.env.CANOPYCMS_DEBUG = 'true'
-
-    const logger = createDebugLogger({ enabled: false })
-    logger.debug('test', 'message')
-
-    expect(console.log).not.toHaveBeenCalled()
-  })
-
-  it('respects minLevel option', () => {
-    const logger = createDebugLogger({ enabled: true, minLevel: 'WARN' })
-
-    logger.debug('test', 'debug message')
-    expect(console.log).not.toHaveBeenCalled()
-
-    logger.info('test', 'info message')
-    expect(console.log).not.toHaveBeenCalled()
-
-    logger.warn('test', 'warn message')
-    expect(console.warn).toHaveBeenCalledOnce()
-
-    logger.error('test', 'error message')
-    expect(console.error).toHaveBeenCalledOnce()
-  })
-
-  it('formats messages correctly', () => {
-    const logger = createDebugLogger({ enabled: true, prefix: 'TestPrefix' })
-    logger.debug('category', 'test message', { foo: 'bar' })
-
-    const call = vi.mocked(console.log).mock.calls[0]
-    expect(call[0]).toContain('[TestPrefix:category]')
-    expect(call[0]).toContain('[DEBUG]')
-    expect(call[0]).toContain('test message')
-    expect(call[1]).toEqual({ foo: 'bar' })
-  })
-
-  it('throws on error when throwOnError is true', () => {
-    const logger = createDebugLogger({ enabled: true, throwOnError: true })
-
-    expect(() => {
-      logger.error('test', 'error message')
-    }).toThrow('error message')
-  })
-
-  it('does not throw on error when throwOnError is false', () => {
-    const logger = createDebugLogger({ enabled: true, throwOnError: false })
-
-    expect(() => {
-      logger.error('test', 'error message')
-    }).not.toThrow()
-  })
-})

package/src/utils/debug.ts

@@ -1,127 +0,0 @@
-export type LogLevel = 'DEBUG' | 'INFO' | 'WARN' | 'ERROR'
-
-export interface DebugOptions {
-  /** Enable/disable logging. Defaults to CANOPYCMS_DEBUG env var */
-  enabled?: boolean
-  /** Minimum log level to display. Defaults to DEBUG */
-  minLevel?: LogLevel
-  /** Prefix for all log messages. Defaults to 'CanopyCMS' */
-  prefix?: string
-  /** Throw an error when logger.error() is called. Defaults to false */
-  throwOnError?: boolean
-}
-
-const LOG_LEVELS: Record<LogLevel, number> = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3,
-}
-
-export class DebugLogger {
-  private options: DebugOptions
-  private timers: Map<string, number> = new Map()
-
-  constructor(options: DebugOptions = {}) {
-    this.options = options
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    // Check enabled at call time to support runtime env var changes
-    const enabled = this.options.enabled ?? process.env.CANOPYCMS_DEBUG === 'true'
-    if (!enabled) return false
-
-    const minLevel = this.options.minLevel ?? 'DEBUG'
-    return LOG_LEVELS[level] >= LOG_LEVELS[minLevel]
-  }
-
-  private formatMessage(level: LogLevel, category: string, message: string): string {
-    const timestamp = new Date().toISOString()
-    const prefix = this.options.prefix ?? 'CanopyCMS'
-    return `[${timestamp}] [${prefix}:${category}] [${level}] ${message}`
-  }
-
-  debug(category: string, message: string, data?: unknown) {
-    if (this.shouldLog('DEBUG')) {
-      console.log(this.formatMessage('DEBUG', category, message), data ?? '')
-    }
-  }
-
-  info(category: string, message: string, data?: unknown) {
-    if (this.shouldLog('INFO')) {
-      console.log(this.formatMessage('INFO', category, message), data ?? '')
-    }
-  }
-
-  warn(category: string, message: string, data?: unknown) {
-    if (this.shouldLog('WARN')) {
-      console.warn(this.formatMessage('WARN', category, message), data ?? '')
-    }
-  }
-
-  error(category: string, message: string, data?: unknown) {
-    const msg = this.formatMessage('ERROR', category, message)
-
-    if (this.shouldLog('ERROR')) {
-      console.error(msg, data ?? '')
-    }
-
-    const throwOnError = this.options.throwOnError ?? false
-    if (throwOnError) {
-      const errorMsg = data ? `${message}: ${JSON.stringify(data)}` : message
-      throw new Error(errorMsg)
-    }
-  }
-
-  /**
-   * Start timing an operation
-   */
-  time(label: string) {
-    this.timers.set(label, Date.now())
-  }
-
-  /**
-   * End timing an operation and log the duration
-   */
-  timeEnd(category: string, label: string) {
-    const start = this.timers.get(label)
-    if (start === undefined) {
-      this.warn(category, `Timer '${label}' does not exist`)
-      return
-    }
-
-    const duration = Date.now() - start
-    this.timers.delete(label)
-    this.debug(category, `${label} completed`, { durationMs: duration })
-    return duration
-  }
-
-  /**
-   * Wrap an async function with automatic timing
-   */
-  async timed<T>(category: string, label: string, fn: () => Promise<T>): Promise<T> {
-    this.time(label)
-    try {
-      return await fn()
-    } finally {
-      this.timeEnd(category, label)
-    }
-  }
-}
-
-/**
- * Create a debug logger instance
- */
-export function createDebugLogger(options?: DebugOptions): DebugLogger {
-  return new DebugLogger(options)
-}
-
-/**
- * Default logger for test infrastructure (E2E tests)
- * Enabled via E2E_DEBUG=true
- */
-export const testLogger = createDebugLogger({
-  enabled: process.env.E2E_DEBUG === 'true',
-  prefix: 'E2E',
-  throwOnError: false,
-})

package/src/utils/error.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { getErrorMessage, isNodeError, isNotFoundError, isPermissionError } from './error'
-
-describe('error utilities', () => {
-  describe('getErrorMessage', () => {
-    it('extracts message from Error instances', () => {
-      const err = new Error('Something went wrong')
-      expect(getErrorMessage(err)).toBe('Something went wrong')
-    })
-
-    it('returns string errors as-is', () => {
-      expect(getErrorMessage('Plain string error')).toBe('Plain string error')
-    })
-
-    it('converts numbers to strings', () => {
-      expect(getErrorMessage(404)).toBe('404')
-    })
-
-    it('converts null to string', () => {
-      expect(getErrorMessage(null)).toBe('null')
-    })
-
-    it('converts undefined to string', () => {
-      expect(getErrorMessage(undefined)).toBe('undefined')
-    })
-
-    it('converts objects to string', () => {
-      expect(getErrorMessage({ code: 'ERR' })).toBe('[object Object]')
-    })
-  })
-
-  describe('isNodeError', () => {
-    it('returns true for errors with code property', () => {
-      const err = Object.assign(new Error('Not found'), { code: 'ENOENT' })
-      expect(isNodeError(err)).toBe(true)
-    })
-
-    it('returns false for plain Error without code', () => {
-      const err = new Error('Plain error')
-      expect(isNodeError(err)).toBe(false)
-    })
-
-    it('returns false for non-Error objects with code', () => {
-      const err = { code: 'ENOENT', message: 'Not found' }
-      expect(isNodeError(err)).toBe(false)
-    })
-
-    it('returns false for strings', () => {
-      expect(isNodeError('ENOENT')).toBe(false)
-    })
-
-    it('returns false for null', () => {
-      expect(isNodeError(null)).toBe(false)
-    })
-  })
-
-  describe('isNotFoundError', () => {
-    it('returns true for ENOENT errors', () => {
-      const err = Object.assign(new Error('Not found'), { code: 'ENOENT' })
-      expect(isNotFoundError(err)).toBe(true)
-    })
-
-    it('returns false for other error codes', () => {
-      const err = Object.assign(new Error('Permission denied'), {
-        code: 'EACCES',
-      })
-      expect(isNotFoundError(err)).toBe(false)
-    })
-
-    it('returns false for errors without code', () => {
-      expect(isNotFoundError(new Error('Not found'))).toBe(false)
-    })
-  })
-
-  describe('isPermissionError', () => {
-    it('returns true for EACCES errors', () => {
-      const err = Object.assign(new Error('Permission denied'), {
-        code: 'EACCES',
-      })
-      expect(isPermissionError(err)).toBe(true)
-    })
-
-    it('returns false for other error codes', () => {
-      const err = Object.assign(new Error('Not found'), { code: 'ENOENT' })
-      expect(isPermissionError(err)).toBe(false)
-    })
-
-    it('returns false for errors without code', () => {
-      expect(isPermissionError(new Error('Permission denied'))).toBe(false)
-    })
-  })
-})

package/src/utils/error.ts

@@ -1,83 +0,0 @@
-/**
- * Error handling utilities for type-safe error handling.
- *
- * These utilities help convert `catch (err: unknown)` to usable error information
- * without using `any` types.
- */
-
-/**
- * Extract a message string from an unknown error value.
- *
- * @param err - The caught error (unknown type)
- * @returns A string message suitable for logging or user display
- *
- * @example
- * ```ts
- * try {
- *   await riskyOperation()
- * } catch (err: unknown) {
- *   console.error('Operation failed:', getErrorMessage(err))
- * }
- * ```
- */
-export function getErrorMessage(err: unknown): string {
-  if (err instanceof Error) {
-    return err.message
-  }
-  if (typeof err === 'string') {
-    return err
-  }
-  return String(err)
-}
-
-/**
- * Type guard to check if an error is a Node.js system error with a code property.
- *
- * @param err - The caught error (unknown type)
- * @returns True if the error has a `code` property (like ENOENT, EACCES, etc.)
- *
- * @example
- * ```ts
- * try {
- *   await fs.readFile(path)
- * } catch (err: unknown) {
- *   if (isNodeError(err) && err.code === 'ENOENT') {
- *     return null // File not found is expected
- *   }
- *   throw err
- * }
- * ```
- */
-export function isNodeError(err: unknown): err is NodeJS.ErrnoException {
-  return err instanceof Error && 'code' in err
-}
-
-/**
- * Check if an error indicates a "file not found" condition.
- *
- * @param err - The caught error (unknown type)
- * @returns True if the error is ENOENT (file/directory not found)
- */
-export function isNotFoundError(err: unknown): boolean {
-  return isNodeError(err) && err.code === 'ENOENT'
-}
-
-/**
- * Check if an error indicates a "permission denied" condition.
- *
- * @param err - The caught error (unknown type)
- * @returns True if the error is EACCES (permission denied)
- */
-export function isPermissionError(err: unknown): boolean {
-  return isNodeError(err) && err.code === 'EACCES'
-}
-
-/**
- * Check if an error indicates a "file already exists" condition.
- *
- * @param err - The caught error (unknown type)
- * @returns True if the error is EEXIST (file already exists)
- */
-export function isFileExistsError(err: unknown): boolean {
-  return isNodeError(err) && err.code === 'EEXIST'
-}

package/src/utils/format.ts

@@ -1,12 +0,0 @@
-import type { ContentFormat } from '../config'
-
-/**
- * Get the file extension for a content format
- * @param format - The content format (md, mdx, json)
- * @returns The file extension including the dot (e.g., '.md', '.json')
- */
-export const getFormatExtension = (format: ContentFormat): string => {
-  if (format === 'md') return '.md'
-  if (format === 'mdx') return '.mdx'
-  return '.json'
-}