polen 0.11.0-next.2 → 0.11.0-next.20

package/src/lib/lifecycles/lifecycles.ts

@@ -0,0 +1,526 @@
+import { Catalog } from '#lib/catalog/$'
+import { Change } from '#lib/change/$'
+import { Revision } from '#lib/revision/$'
+import { Schema } from '#lib/schema/$'
+import { Version } from '#lib/version/$'
+import { Match, Option } from 'effect'
+
+// ============================================================================
+// Lifecycles Type - Simple Index
+// ============================================================================
+
+/**
+ * A change entry tracking when a type or field was modified
+ */
+export interface ChangeEntry {
+  /** The change that occurred */
+  change: Change.Change
+  /** The revision containing this change */
+  revision: Revision.Revision
+  /** The schema this change belongs to */
+  schema: Schema.Schema
+}
+
+/**
+ * Lifecycles is a simple index mapping type names to their change history
+ */
+export type Lifecycles = Record<string, ChangeEntry[]>
+
+// ============================================================================
+// Since Types - For tracking when things were introduced
+// ============================================================================
+
+/**
+ * Represents when a type or field was introduced
+ */
+export type Since =
+  | { _tag: 'initial' }
+  | { _tag: 'added'; revision: Revision.Revision; change: Change.Change; schema: Schema.Schema }
+
+// ============================================================================
+// Domain Logic - Create Function
+// ============================================================================
+
+/**
+ * Extract the type name from a change
+ */
+const extractTypeNameFromChange = (change: Change.Change): Option.Option<string> => {
+  return Match.value(change).pipe(
+    Match.tag('TYPE_ADDED', (c) => Option.some(c.name)),
+    Match.tag('TYPE_REMOVED', (c) => Option.some(c.name)),
+    Match.tag('FIELD_ADDED', (c) => Option.some(c.typeName)),
+    Match.tag('FIELD_REMOVED', (c) => Option.some(c.typeName)),
+    Match.tag('INPUT_FIELD_ADDED', (c) => Option.some(c.inputName)),
+    Match.tag('INPUT_FIELD_REMOVED', (c) => Option.some(c.inputName)),
+    Match.tag('ENUM_VALUE_ADDED', (c) => Option.some(c.enumName)),
+    Match.tag('ENUM_VALUE_REMOVED', (c) => Option.some(c.enumName)),
+    Match.tag('UNION_MEMBER_ADDED', (c) => Option.some(c.unionName)),
+    Match.tag('UNION_MEMBER_REMOVED', (c) => Option.some(c.unionName)),
+    Match.tag('OBJECT_TYPE_INTERFACE_ADDED', (c) => Option.some(c.objectName)),
+    Match.tag('OBJECT_TYPE_INTERFACE_REMOVED', (c) => Option.some(c.objectName)),
+    Match.orElse(() => Option.none()),
+  )
+}
+
+/**
+ * Build lifecycle data from a single schema
+ */
+export const createFromSchema = (schema: Schema.Schema): Lifecycles => {
+  const lifecycles: Lifecycles = {}
+
+  // Process all revisions for this schema
+  for (const revision of schema.revisions) {
+    // Process all changes in this revision
+    for (const change of revision.changes) {
+      const typeNameOption = extractTypeNameFromChange(change)
+      if (Option.isSome(typeNameOption)) {
+        const typeName = typeNameOption.value
+        if (!lifecycles[typeName]) {
+          lifecycles[typeName] = []
+        }
+        lifecycles[typeName].push({
+          change, // reference to existing change object
+          revision, // reference to existing revision object
+          schema, // reference to existing schema object
+        })
+      }
+    }
+  }
+
+  return lifecycles
+}
+
+/**
+ * Build lifecycle data from a catalog
+ */
+export const create = (catalog: Catalog.Catalog): Lifecycles => {
+  const lifecycles: Lifecycles = {}
+
+  const processSchema = (schema: Schema.Schema) => {
+    // Process all revisions for this schema
+    for (const revision of schema.revisions) {
+      // Process all changes in this revision
+      for (const change of revision.changes) {
+        const typeNameOption = extractTypeNameFromChange(change)
+        if (Option.isSome(typeNameOption)) {
+          const typeName = typeNameOption.value
+          if (!lifecycles[typeName]) {
+            lifecycles[typeName] = []
+          }
+          lifecycles[typeName].push({
+            change, // reference to existing change object
+            revision, // reference to existing revision object
+            schema, // reference to existing schema object
+          })
+        }
+      }
+    }
+  }
+
+  // Process based on catalog type
+  Catalog.fold(
+    // Versioned catalog - process each versioned schema
+    (versioned) => {
+      for (const schema of Catalog.Versioned.getAll(versioned)) {
+        processSchema(schema)
+      }
+    },
+    // Unversioned catalog - process the single schema
+    (unversioned) => {
+      processSchema(unversioned.schema)
+    },
+  )(catalog)
+
+  return lifecycles
+}
+
+// ============================================================================
+// Domain Logic - Utility Functions for Types
+// ============================================================================
+
+/**
+ * Get when a type was introduced (initial or added)
+ */
+export const getTypeSince = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentSchema?: Schema.Schema,
+): Since | undefined => {
+  const entries = lifecycles[typeName]
+
+  // If no entries at all, type doesn't exist in any form
+  if (!entries || entries.length === 0) return undefined
+
+  // Look for TYPE_ADDED change
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_ADDED' && entry.change.name === typeName) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentSchema && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema._tag !== 'SchemaVersioned') throw new Error('todo -- version/unversioned mismatch!')
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentSchema.version)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      // Found when it was added
+      return {
+        _tag: 'added',
+        revision: entry.revision,
+        change: entry.change,
+        schema: entry.schema,
+      }
+    }
+  }
+
+  // No TYPE_ADDED found, so it must have existed from initial schema
+  return { _tag: 'initial' }
+}
+
+/**
+ * Get the date when a type was added
+ * Shows when the type was first introduced via TYPE_ADDED change
+ * Returns undefined if type existed from initial schema (no TYPE_ADDED change)
+ */
+export const getTypeAddedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentVersion?: string,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Parse current version if provided
+  const currentVer = currentVersion ? Version.fromString(currentVersion) : undefined
+
+  // Find the earliest TYPE_ADDED change that's not after the current version
+  let earliestDate: Date | undefined
+
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_ADDED' && entry.change.name === typeName) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      const date = new Date(entry.revision.date)
+      if (!earliestDate || date < earliestDate) {
+        earliestDate = date
+      }
+    }
+  }
+
+  return earliestDate
+}
+
+/**
+ * Get the date when a type was removed
+ * For reference docs: Returns undefined if type exists in current version (no removal badge should be shown)
+ * For changelog: Shows removal date if it happened in any version
+ */
+export const getTypeRemovedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // If no current schema specified (e.g., in changelog), show any removal
+  if (!currentSchema) {
+    // Find the latest TYPE_REMOVED change
+    let latestDate: Date | undefined
+
+    for (const entry of entries) {
+      if (entry.change._tag === 'TYPE_REMOVED' && entry.change.name === typeName) {
+        const date = new Date(entry.revision.date)
+        if (!latestDate || date > latestDate) {
+          latestDate = date
+        }
+      }
+    }
+
+    return latestDate
+  }
+
+  // For reference docs with current schema:
+  // Only show removal if it happens AFTER the current version (future removal warning)
+  // If the type exists in the current version, it cannot have been removed
+  const currentVer = Schema.getVersion(currentSchema)
+  if (!currentVer) return undefined
+
+  for (const entry of entries) {
+    if (entry.change._tag === 'TYPE_REMOVED' && entry.change.name === typeName) {
+      // Check if removal is after current version
+      if (entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema._tag !== 'SchemaVersioned') throw new Error('todo -- version/unversioned mismatch!')
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          // This is a future removal - could show as a deprecation warning
+          // But for now, we don't show future removals
+          return undefined
+        }
+      }
+    }
+  }
+
+  // No removal found or removal is in the past (but type still exists in current version)
+  return undefined
+}
+
+/**
+ * Check if a type is currently available (not removed)
+ */
+export const isTypeCurrentlyAvailable = (lifecycles: Lifecycles, typeName: string): boolean => {
+  const entries = lifecycles[typeName]
+  if (!entries || entries.length === 0) return false
+
+  // Check if type was ever added
+  const wasAdded = entries.some(e => e.change._tag === 'TYPE_ADDED' && e.change.name === typeName)
+  if (!wasAdded) return false
+
+  // Check if it was subsequently removed
+  const addedDate = getTypeAddedDate(lifecycles, typeName)
+  const removedDate = getTypeRemovedDate(lifecycles, typeName)
+
+  if (!addedDate) return false
+  if (!removedDate) return true
+
+  // If both dates exist, type is available if it was re-added after being removed
+  // This would require multiple add/remove cycles - for now assume removed means not available
+  return false
+}
+
+// ============================================================================
+// Domain Logic - Utility Functions for Fields
+// ============================================================================
+
+/**
+ * Get when a field was introduced (initial or added)
+ */
+export const getFieldSince = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Since | undefined => {
+  const entries = lifecycles[typeName]
+
+  // If no entries for the type, we can't determine field info
+  if (!entries || entries.length === 0) return undefined
+
+  // Get current version from schema if provided
+  const currentVer = currentSchema ? Schema.getVersion(currentSchema) : undefined
+
+  // Look for FIELD_ADDED or INPUT_FIELD_ADDED change
+  for (const entry of entries) {
+    const isFieldAdded = (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+
+    if (isFieldAdded) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema && currentSchema._tag !== 'SchemaVersioned') {
+          throw new Error('todo -- version/unversioned mismatch!')
+        }
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      // Found when it was added
+      return {
+        _tag: 'added',
+        revision: entry.revision,
+        change: entry.change,
+        schema: entry.schema,
+      }
+    }
+  }
+
+  // No FIELD_ADDED found, so it must have existed from initial schema
+  // But only if the type itself exists (has some entries)
+  return { _tag: 'initial' }
+}
+
+/**
+ * Get the date when a field was added
+ * Shows when the field was first introduced via FIELD_ADDED change
+ * Returns undefined if field existed from initial schema (no FIELD_ADDED change)
+ */
+export const getFieldAddedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // Get current version from schema if provided
+  const currentVer = currentSchema ? Schema.getVersion(currentSchema) : undefined
+
+  // Find the earliest FIELD_ADDED or INPUT_FIELD_ADDED change for this field
+  let earliestDate: Date | undefined
+
+  for (const entry of entries) {
+    const isFieldAdded = (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+
+    if (isFieldAdded) {
+      // If we have a current version and this entry has a version, check if it's not after current
+      if (currentVer && entry.schema._tag === 'SchemaVersioned') {
+        if (currentSchema && currentSchema._tag !== 'SchemaVersioned') {
+          throw new Error('todo -- version/unversioned mismatch!')
+        }
+        const entryVer = entry.schema.version
+        if (Version.greaterThan(entryVer, currentVer)) {
+          continue // Skip entries from future versions
+        }
+      }
+
+      const date = new Date(entry.revision.date)
+      if (!earliestDate || date < earliestDate) {
+        earliestDate = date
+      }
+    }
+  }
+
+  return earliestDate
+}
+
+/**
+ * Get the date when a field was removed
+ * For reference docs: Returns undefined if field exists in current version (no removal badge should be shown)
+ * For changelog: Shows removal date if it happened in any version
+ */
+export const getFieldRemovedDate = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+  currentSchema?: Schema.Schema,
+): Date | undefined => {
+  const entries = lifecycles[typeName]
+  if (!entries) return undefined
+
+  // If no current schema specified (e.g., in changelog), show any removal
+  if (!currentSchema) {
+    // Find the latest FIELD_REMOVED or INPUT_FIELD_REMOVED change for this field
+    let latestDate: Date | undefined
+
+    for (const entry of entries) {
+      const isFieldRemoved = (entry.change._tag === 'FIELD_REMOVED'
+        && entry.change.typeName === typeName
+        && entry.change.fieldName === fieldName)
+        || (entry.change._tag === 'INPUT_FIELD_REMOVED'
+          && entry.change.inputName === typeName
+          && entry.change.fieldName === fieldName)
+
+      if (isFieldRemoved) {
+        const date = new Date(entry.revision.date)
+        if (!latestDate || date > latestDate) {
+          latestDate = date
+        }
+      }
+    }
+
+    return latestDate
+  }
+
+  // For reference docs with current version:
+  // If the field exists in the current version's schema, it cannot have been removed
+  // So we return undefined (no removal badge should be shown)
+  return undefined
+}
+
+/**
+ * Check if a field is currently available (not removed)
+ */
+export const isFieldCurrentlyAvailable = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+): boolean => {
+  const entries = lifecycles[typeName]
+  if (!entries || entries.length === 0) return false
+
+  // Check if field was ever added
+  const addedDate = getFieldAddedDate(lifecycles, typeName, fieldName)
+  if (!addedDate) return false
+
+  // Check if it was subsequently removed
+  const removedDate = getFieldRemovedDate(lifecycles, typeName, fieldName)
+  if (!removedDate) return true
+
+  // If both dates exist, field is not available if it was removed
+  return false
+}
+
+// ============================================================================
+// Domain Logic - Compatibility Functions (for existing code)
+// ============================================================================
+
+/**
+ * Get field lifecycle info (for compatibility with existing UI code)
+ */
+export const getFieldLifecycle = (
+  lifecycles: Lifecycles,
+  typeName: string,
+  fieldName: string,
+): Option.Option<{ events: ChangeEntry[] }> => {
+  const entries = lifecycles[typeName]
+  if (!entries) return Option.none()
+
+  // Filter entries related to this specific field
+  const fieldEntries = entries.filter(entry => {
+    return (entry.change._tag === 'FIELD_ADDED'
+      && entry.change.typeName === typeName
+      && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'FIELD_REMOVED'
+        && entry.change.typeName === typeName
+        && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_ADDED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+      || (entry.change._tag === 'INPUT_FIELD_REMOVED'
+        && entry.change.inputName === typeName
+        && entry.change.fieldName === fieldName)
+  })
+
+  if (fieldEntries.length === 0) return Option.none()
+
+  // Return in a format compatible with existing code that expects an object with events
+  return Option.some({ events: fieldEntries })
+}
+
+/**
+ * Get type lifecycle info (for compatibility with existing UI code)
+ */
+export const getTypeLifecycle = (
+  lifecycles: Lifecycles,
+  typeName: string,
+): Option.Option<{ events: ChangeEntry[] }> => {
+  const entries = lifecycles[typeName]
+  if (!entries) return Option.none()
+
+  // Filter entries related to type-level changes
+  const typeEntries = entries.filter(entry => {
+    return entry.change._tag === 'TYPE_ADDED' || entry.change._tag === 'TYPE_REMOVED'
+  })
+
+  if (typeEntries.length === 0) return Option.none()
+
+  return Option.some({ events: typeEntries })
+}

package/src/lib/memory-filesystem/$$.ts

@@ -0,0 +1 @@
+export * from './memory-filesystem.js'

package/src/lib/memory-filesystem/$.ts

@@ -0,0 +1 @@
+export * as MemoryFilesystem from './$$.js'

package/src/lib/memory-filesystem/memory-filesystem.ts

@@ -0,0 +1,162 @@
+import { SystemError } from '@effect/platform/Error'
+import { FileSystem } from '@effect/platform/FileSystem'
+import { Effect, Layer } from 'effect'
+
+// ============================================================================
+// Error Factories
+// ============================================================================
+
+const createUnsupportedError = (method: string, operation: string) =>
+  new SystemError({
+    reason: 'PermissionDenied',
+    module: 'FileSystem',
+    method,
+    description: `${operation} not supported in memory filesystem`,
+  })
+
+const createNotFoundError = (method: string, path: string, operation: string) =>
+  new SystemError({
+    reason: 'NotFound',
+    module: 'FileSystem',
+    method,
+    pathOrDescriptor: path,
+    description: `ENOENT: no such file or directory, ${operation} '${path}'`,
+  })
+
+// Convenience factories for common patterns
+const failUnsupported = (method: string, operation: string) => Effect.fail(createUnsupportedError(method, operation))
+
+const failNotFound = (method: string, path: string, operation: string) =>
+  Effect.fail(createNotFoundError(method, path, operation))
+
+// ============================================================================
+// Memory Filesystem Types
+// ============================================================================
+
+/**
+ * Memory filesystem disk layout specification.
+ * Keys are file paths, values are file contents as strings.
+ */
+export interface DiskLayout {
+  readonly [path: string]: string
+}
+
+// ============================================================================
+// Memory Filesystem Layer Factory
+// ============================================================================
+
+/**
+ * Creates a memory filesystem layer from a disk layout specification.
+ * This layer can be composed with other layers for testing.
+ *
+ * @param diskLayout - Object mapping file paths to their contents
+ * @returns Layer that provides a FileSystem service backed by memory
+ */
+export const layer = (diskLayout: DiskLayout) =>
+  Layer.succeed(
+    FileSystem,
+    {
+      // File existence check
+      exists: (path: string) => Effect.succeed(path in diskLayout),
+
+      // Read file as string
+      readFileString: (path: string) => {
+        const content = diskLayout[path]
+        return content !== undefined
+          ? Effect.succeed(content)
+          : failNotFound('readFileString', path, 'open')
+      },
+
+      // Read directory contents
+      readDirectory: (path: string) => {
+        const normalizedPath = path.endsWith('/') ? path : path + '/'
+        const entries = Object.keys(diskLayout)
+          .filter(filePath => filePath.startsWith(normalizedPath))
+          .map(filePath => filePath.slice(normalizedPath.length))
+          .filter(relativePath => relativePath.length > 0 && !relativePath.includes('/'))
+
+        return entries.length > 0
+          ? Effect.succeed(entries)
+          : failNotFound('readDirectory', path, 'scandir')
+      },
+
+      // File stats (simplified - just checks existence)
+      stat: (path: string) => {
+        if (path in diskLayout) {
+          return Effect.succeed({
+            isFile: () => true,
+            isDirectory: () => false,
+            isSymbolicLink: () => false,
+            size: diskLayout[path]!.length,
+          } as any)
+        }
+
+        // Check if it's a directory (has files under it)
+        const normalizedPath = path.endsWith('/') ? path : path + '/'
+        const hasChildren = Object.keys(diskLayout).some(filePath =>
+          filePath.startsWith(normalizedPath) && filePath !== path
+        )
+
+        if (hasChildren) {
+          return Effect.succeed({
+            isFile: () => false,
+            isDirectory: () => true,
+            isSymbolicLink: () => false,
+            size: 0,
+          } as any)
+        }
+
+        return failNotFound('stat', path, 'stat')
+      },
+
+      // Stub implementations for write operations (not needed for read-only testing)
+      writeFileString: () => failUnsupported('writeFileString', 'Write operations'),
+      writeFile: () => failUnsupported('writeFile', 'Write operations'),
+      truncate: () => failUnsupported('truncate', 'Write operations'),
+      remove: () => failUnsupported('remove', 'Write operations'),
+      makeDirectory: () => failUnsupported('makeDirectory', 'Write operations'),
+      makeTempDirectory: () => failUnsupported('makeTempDirectory', 'Write operations'),
+      makeTempDirectoryScoped: () => failUnsupported('makeTempDirectoryScoped', 'Write operations'),
+      makeTempFile: () => failUnsupported('makeTempFile', 'Write operations'),
+      makeTempFileScoped: () => failUnsupported('makeTempFileScoped', 'Write operations'),
+      open: () => failUnsupported('open', 'File operations'),
+      copy: () => failUnsupported('copy', 'Write operations'),
+      copyFile: () => failUnsupported('copyFile', 'Write operations'),
+      chmod: () => failUnsupported('chmod', 'Write operations'),
+      chown: () => failUnsupported('chown', 'Write operations'),
+      access: (path: string) =>
+        path in diskLayout
+          ? Effect.void
+          : failNotFound('access', path, 'access'),
+      link: () => failUnsupported('link', 'Write operations'),
+      realPath: (path: string) => Effect.succeed(path),
+      readFile: (path: string) => {
+        const content = diskLayout[path]
+        return content !== undefined
+          ? Effect.succeed(new TextEncoder().encode(content))
+          : failNotFound('readFile', path, 'open')
+      },
+      readLink: () => failUnsupported('readLink', 'Symlink operations'),
+      symlink: () => failUnsupported('symlink', 'Write operations'),
+      utimes: () => failUnsupported('utimes', 'Write operations'),
+      watch: () => failUnsupported('watch', 'Watch operations'),
+
+      // Rename/move files (not implemented for memory filesystem)
+      rename: () => failUnsupported('rename', 'Write operations'),
+
+      // Create writable sink (not implemented for memory filesystem)
+      sink: () => failUnsupported('sink', 'Stream operations'),
+
+      // Create readable stream (not implemented for memory filesystem)
+      stream: () => failUnsupported('stream', 'Stream operations'),
+    },
+  )
+
+/**
+ * Convenience function for creating memory filesystem layers from disk layout.
+ * This matches the API used in schema tests.
+ *
+ * @param diskLayout - Object mapping file paths to their contents
+ * @returns Layer that provides an Effect Platform FileSystem service backed by memory
+ */
+export const layerFromDiskLayout = (diskLayout: DiskLayout) => layer(diskLayout)