@piqit/resolvers 0.0.2 → 0.0.3

package/package.json

@@ -1,28 +1,28 @@
 {
   "name": "@piqit/resolvers",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "type": "module",
   "license": "MIT",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./edge": {
-      "types": "./src/edge.ts",
-      "import": "./src/edge.ts"
+      "types": "./dist/edge.d.ts",
+      "default": "./dist/edge.js"
     },
     "./static": {
-      "types": "./src/static.ts",
-      "import": "./src/static.ts"
+      "types": "./dist/static.d.ts",
+      "default": "./dist/static.js"
     }
   },
   "files": [
-    "src",
     "dist"
   ],
   "dependencies": {
-    "piqit": "0.0.2"
+    "piqit": "0.0.3"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/edge.ts

@@ -1,15 +0,0 @@
-/**
- * @piqit/resolvers/edge - Edge-compatible resolvers
- *
- * This entry point only exports resolvers that work in edge environments
- * like Cloudflare Workers, where dynamic code generation is not allowed.
- *
- * Use this instead of '@piqit/resolvers' in your Worker:
- *
- * @example
- * import { staticContent } from "@piqit/resolvers/edge";
- *
- * @packageDocumentation
- */
-
-export { staticContent, staticResolver } from "./static"

package/src/file-markdown.ts

@@ -1,352 +0,0 @@
-/**
- * Filesystem Markdown Resolver
- *
- * A resolver for querying markdown files from the filesystem.
- * Optimized for reading only what's needed based on the query.
- */
-
-import type { Resolver, StandardSchema, Infer } from "piqit"
-import { compilePattern, createParamsSchema, type PathParams } from "./path-pattern"
-import { parseFrontmatter } from "./frontmatter"
-import { parseMarkdownBody, type BodyOptions, type BodyResult, type Heading } from "./markdown"
-import path from "node:path"
-
-// =============================================================================
-// Types
-// =============================================================================
-
-/**
- * Options for creating a file markdown resolver.
- */
-export interface FileMarkdownOptions<
-  TPath extends string,
-  TFrontmatter extends StandardSchema,
-  TBody extends BodyOptions
-> {
-  /**
-   * Base directory for finding files.
-   * Can be absolute or relative to cwd.
-   */
-  base: string
-
-  /**
-   * Path pattern with {param} placeholders.
-   * @example '{year}/{slug}.md'
-   */
-  path: TPath
-
-  /**
-   * Schema for validating frontmatter.
-   * The schema's inferred type defines filter parameters.
-   */
-  frontmatter: TFrontmatter
-
-  /**
-   * Body parsing options.
-   * @default { raw: false, html: false, headings: false }
-   */
-  body?: TBody
-}
-
-/**
- * The shape of results from a file markdown resolver.
- */
-export interface FileMarkdownResult<
-  TParams,
-  TFrontmatter,
-  TBody extends BodyResult
-> {
-  params: TParams
-  frontmatter: TFrontmatter
-  body: TBody
-}
-
-/**
- * Type for body shape based on options.
- */
-type ComputedBodyShape<T extends BodyOptions | undefined> = T extends BodyOptions
-  ? {
-      raw: T["raw"] extends true ? string : never
-      html: T["html"] extends true ? string : never
-      headings: T["headings"] extends true ? Heading[] : never
-    }
-  : Record<string, never>
-
-/**
- * Clean up body shape to remove never types.
- */
-type CleanBodyShape<T> = {
-  [K in keyof T as T[K] extends never ? never : K]: T[K]
-}
-
-// =============================================================================
-// Result Schema Factory
-// =============================================================================
-
-/**
- * Create a result schema for the resolver.
- * This schema validates the namespaced result shape.
- */
-function createResultSchema<TFrontmatter, TBody extends BodyResult>(
-  _paramNames: string[],
-  frontmatterSchema: StandardSchema<TFrontmatter>,
-  bodyOptions: BodyOptions
-): StandardSchema<FileMarkdownResult<Record<string, string>, TFrontmatter, TBody>> {
-  return {
-    "~standard": {
-      version: 1,
-      vendor: "piqit/resolvers",
-      validate(value: unknown) {
-        if (value === null || typeof value !== "object") {
-          return { issues: [{ message: "Expected object" }] }
-        }
-
-        const obj = value as Record<string, unknown>
-
-        // Validate params
-        if (obj.params == null || typeof obj.params !== "object") {
-          return { issues: [{ message: "Missing params", path: ["params"] }] }
-        }
-
-        // Validate frontmatter using the provided schema
-        const fmResult = frontmatterSchema["~standard"].validate(obj.frontmatter)
-        if (fmResult.issues) {
-          return {
-            issues: fmResult.issues.map((issue) => ({
-              ...issue,
-              path: ["frontmatter", ...(issue.path || [])],
-            })),
-          }
-        }
-
-        // Validate body shape
-        if (bodyOptions.raw || bodyOptions.html || bodyOptions.headings) {
-          if (obj.body == null || typeof obj.body !== "object") {
-            return { issues: [{ message: "Missing body", path: ["body"] }] }
-          }
-        }
-
-        return { value: obj as unknown as FileMarkdownResult<Record<string, string>, TFrontmatter, TBody> }
-      },
-    },
-  }
-}
-
-// =============================================================================
-// Helper Functions
-// =============================================================================
-
-/**
- * Check if any select paths require frontmatter data.
- */
-function needsFrontmatter(selectPaths: string[]): boolean {
-  return selectPaths.some((p) => p.startsWith("frontmatter.") || p === "frontmatter.*")
-}
-
-/**
- * Check if any select paths require body data.
- */
-function needsBody(selectPaths: string[]): boolean {
-  return selectPaths.some((p) => p.startsWith("body.") || p === "body.*")
-}
-
-/**
- * Check if any select paths require params.
- */
-function needsParams(selectPaths: string[]): boolean {
-  return selectPaths.some((p) => p.startsWith("params.") || p === "params.*")
-}
-
-/**
- * Get which body parts are needed based on select paths.
- */
-function getNeededBodyParts(selectPaths: string[]): BodyOptions {
-  const result: BodyOptions = {}
-
-  for (const path of selectPaths) {
-    if (path === "body.*") {
-      // Need all body parts
-      return { raw: true, html: true, headings: true }
-    }
-    if (path === "body.raw") result.raw = true
-    if (path === "body.html") result.html = true
-    if (path === "body.headings") result.headings = true
-  }
-
-  return result
-}
-
-/**
- * Check if filter constraints match frontmatter.
- * Simple equality check for now.
- */
-function matchesFilter(
-  frontmatter: Record<string, unknown>,
-  filter: Record<string, unknown>
-): boolean {
-  for (const [key, value] of Object.entries(filter)) {
-    if (frontmatter[key] !== value) {
-      return false
-    }
-  }
-  return true
-}
-
-// =============================================================================
-// Resolver Factory
-// =============================================================================
-
-/**
- * Create a filesystem markdown resolver.
- *
- * @example
- * const postsResolver = fileMarkdown({
- *   base: 'content/posts',
- *   path: '{year}/{slug}.md',
- *   frontmatter: z.object({
- *     title: z.string(),
- *     status: z.enum(['draft', 'published']),
- *   }),
- *   body: { html: true, headings: true }
- * })
- */
-export function fileMarkdown<
-  TPath extends string,
-  TFrontmatter extends StandardSchema,
-  TBody extends BodyOptions = Record<string, never>
->(
-  options: FileMarkdownOptions<TPath, TFrontmatter, TBody>
-): Resolver<
-  StandardSchema<Partial<PathParams<TPath>>>,
-  TFrontmatter,
-  StandardSchema<
-    FileMarkdownResult<
-      PathParams<TPath>,
-      Infer<TFrontmatter>,
-      CleanBodyShape<ComputedBodyShape<TBody>>
-    >
-  >
-> {
-  const pattern = compilePattern(options.path)
-  const basePath = path.isAbsolute(options.base)
-    ? options.base
-    : path.join(process.cwd(), options.base)
-
-  const bodyOptions: BodyOptions = options.body || {}
-
-  // Create schemas
-  const scanSchema = createParamsSchema(pattern) as StandardSchema<Partial<PathParams<TPath>>>
-  const resultSchema = createResultSchema(
-    pattern.paramNames,
-    options.frontmatter,
-    bodyOptions
-  ) as StandardSchema<
-    FileMarkdownResult<
-      PathParams<TPath>,
-      Infer<TFrontmatter>,
-      CleanBodyShape<ComputedBodyShape<TBody>>
-    >
-  >
-
-  return {
-    schema: {
-      scanParams: scanSchema,
-      filterParams: options.frontmatter,
-      result: resultSchema,
-    },
-
-    async resolve(spec) {
-      const results: Array<
-        Partial<
-          FileMarkdownResult<
-            PathParams<TPath>,
-            Infer<TFrontmatter>,
-            CleanBodyShape<ComputedBodyShape<TBody>>
-          >
-        >
-      > = []
-
-      // 1. Generate glob pattern from scan constraints
-      const globPattern = pattern.toGlob(spec.scan as Record<string, unknown>)
-
-      // 2. Find matching files using Bun.Glob
-      const glob = new Bun.Glob(globPattern)
-      const files: string[] = []
-
-      for await (const file of glob.scan({ cwd: basePath, absolute: false })) {
-        files.push(file)
-      }
-
-      // 3. Determine what we need to read
-      const wantParams = needsParams(spec.select)
-      const wantFrontmatter = needsFrontmatter(spec.select)
-      const wantBody = needsBody(spec.select)
-      const hasFilter = spec.filter && Object.keys(spec.filter).length > 0
-      const neededBodyParts = wantBody ? getNeededBodyParts(spec.select) : {}
-
-      // 4. Process each file
-      for (const relativePath of files) {
-        // Extract params from path
-        const params = pattern.match(relativePath)
-        if (!params) continue
-
-        const fullPath = path.join(basePath, relativePath)
-
-        // Read file content only if needed
-        let content: string | null = null
-        let frontmatter: Record<string, unknown> | null = null
-        let body: BodyResult | null = null
-
-        // If filtering or selecting frontmatter, we need to read it
-        if (hasFilter || wantFrontmatter) {
-          content = await Bun.file(fullPath).text()
-          frontmatter = parseFrontmatter(content)
-
-          if (!frontmatter) {
-            frontmatter = {}
-          }
-
-          // Check filter constraints
-          if (hasFilter && !matchesFilter(frontmatter, spec.filter as Record<string, unknown>)) {
-            continue
-          }
-        }
-
-        // If selecting body, parse it
-        if (wantBody) {
-          if (!content) {
-            content = await Bun.file(fullPath).text()
-          }
-
-          // Only parse the body parts that are needed
-          body = parseMarkdownBody(content, neededBodyParts)
-        }
-
-        // Build result with only requested fields
-        const result: Partial<
-          FileMarkdownResult<
-            PathParams<TPath>,
-            Infer<TFrontmatter>,
-            CleanBodyShape<ComputedBodyShape<TBody>>
-          >
-        > = {}
-
-        if (wantParams) {
-          result.params = params as PathParams<TPath>
-        }
-
-        if (wantFrontmatter) {
-          result.frontmatter = frontmatter as Infer<TFrontmatter>
-        }
-
-        if (wantBody && body) {
-          result.body = body as CleanBodyShape<ComputedBodyShape<TBody>>
-        }
-
-        results.push(result)
-      }
-
-      return results
-    },
-  }
-}

package/src/frontmatter.ts

@@ -1,269 +0,0 @@
-/**
- * YAML Frontmatter Extraction
- *
- * Optimized frontmatter parsing that reads only what's needed.
- */
-
-// =============================================================================
-// Frontmatter Parsing
-// =============================================================================
-
-/**
- * Regex to match YAML frontmatter block at the start of content.
- * Matches --- at start, captures content, ends with ---
- */
-const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---/
-
-/**
- * Parse YAML frontmatter from content string.
- *
- * Uses a simple YAML parser that handles common cases:
- * - key: value
- * - key: "quoted value"
- * - key: 'quoted value'
- * - key: [array, items]
- * - Multi-line values with proper indentation
- *
- * @param content - The file content (or just the frontmatter portion)
- * @returns The parsed frontmatter object, or null if not found
- */
-export function parseFrontmatter(content: string): Record<string, unknown> | null {
-  const match = FRONTMATTER_REGEX.exec(content)
-  if (!match) return null
-
-  const yaml = match[1]
-  return parseSimpleYaml(yaml)
-}
-
-/**
- * Extract just the frontmatter portion from content.
- * Returns the raw YAML string without the --- delimiters.
- *
- * @param content - The file content
- * @returns The YAML content, or null if no frontmatter
- */
-export function extractFrontmatterString(content: string): string | null {
-  const match = FRONTMATTER_REGEX.exec(content)
-  return match ? match[1] : null
-}
-
-/**
- * Get the byte offset where frontmatter ends (after closing ---).
- * Returns 0 if no frontmatter found.
- *
- * @param content - The file content
- * @returns Byte offset after frontmatter, or 0
- */
-export function getFrontmatterEndOffset(content: string): number {
-  const match = FRONTMATTER_REGEX.exec(content)
-  if (!match) return 0
-  return match[0].length
-}
-
-// =============================================================================
-// Simple YAML Parser
-// =============================================================================
-
-/**
- * Parse simple YAML into an object.
- * Handles the common patterns found in markdown frontmatter.
- */
-function parseSimpleYaml(yaml: string): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  const lines = yaml.split(/\r?\n/)
-
-  let currentKey: string | null = null
-  let currentValue: string[] = []
-  let inMultiline = false
-  let inBlockArray = false
-  let blockArrayItems: unknown[] = []
-  let multilineIndent = 0
-
-  function commitValue() {
-    if (currentKey) {
-      if (inBlockArray) {
-        // Commit block array
-        result[currentKey] = blockArrayItems
-        blockArrayItems = []
-        inBlockArray = false
-      } else if (currentValue.length === 1) {
-        result[currentKey] = parseYamlValue(currentValue[0])
-      } else if (currentValue.length > 1) {
-        result[currentKey] = currentValue.join("\n")
-      }
-    }
-    currentKey = null
-    currentValue = []
-    inMultiline = false
-  }
-
-  for (const line of lines) {
-    // Check for block array item (- value)
-    const arrayItemMatch = line.match(/^(\s+)-\s+(.*)$/)
-    if (arrayItemMatch && currentKey && (inBlockArray || (inMultiline && currentValue.length === 0))) {
-      inBlockArray = true
-      inMultiline = false
-      const itemValue = arrayItemMatch[2].trim()
-      blockArrayItems.push(parseYamlValue(itemValue))
-      continue
-    }
-
-    // Check for key: value pattern
-    const keyMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/)
-
-    if (keyMatch && !inMultiline) {
-      // Commit previous key-value
-      commitValue()
-
-      currentKey = keyMatch[1]
-      const valueStr = keyMatch[2].trim()
-
-      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-        // Multiline value or block array starts on next line
-        inMultiline = true
-        multilineIndent = 0
-      } else {
-        currentValue = [valueStr]
-      }
-    } else if (inMultiline && currentKey && !inBlockArray) {
-      // Continuation of multiline value
-      if (line.trim() === "") {
-        currentValue.push("")
-      } else {
-        const indent = line.search(/\S/)
-        if (indent > 0) {
-          if (multilineIndent === 0) {
-            multilineIndent = indent
-          }
-          currentValue.push(line.slice(multilineIndent))
-        } else {
-          // No indent means new key or end of multiline
-          commitValue()
-          // Re-process this line
-          const reKeyMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/)
-          if (reKeyMatch) {
-            currentKey = reKeyMatch[1]
-            const valueStr = reKeyMatch[2].trim()
-            if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-              inMultiline = true
-              multilineIndent = 0
-            } else {
-              currentValue = [valueStr]
-            }
-          }
-        }
-      }
-    } else if (currentKey && line.trim() === "") {
-      // Empty line after value - keep going
-    } else if (!currentKey && line.trim() !== "") {
-      // New key-value
-      const newKeyMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/)
-      if (newKeyMatch) {
-        currentKey = newKeyMatch[1]
-        const valueStr = newKeyMatch[2].trim()
-        if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-          inMultiline = true
-          multilineIndent = 0
-        } else {
-          currentValue = [valueStr]
-        }
-      }
-    }
-  }
-
-  // Commit final value
-  commitValue()
-
-  return result
-}
-
-/**
- * Parse a single YAML value.
- */
-function parseYamlValue(value: string): unknown {
-  // Remove quotes
-  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-    return value.slice(1, -1)
-  }
-
-  // Check for array
-  if (value.startsWith("[") && value.endsWith("]")) {
-    const inner = value.slice(1, -1)
-    if (inner.trim() === "") return []
-    return inner.split(",").map((item) => parseYamlValue(item.trim()))
-  }
-
-  // Check for booleans
-  if (value === "true") return true
-  if (value === "false") return false
-
-  // Check for null
-  if (value === "null" || value === "~") return null
-
-  // Check for numbers
-  const num = Number(value)
-  if (!isNaN(num) && value !== "") return num
-
-  // Check for dates (ISO format)
-  if (/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/.test(value)) {
-    const date = new Date(value)
-    if (!isNaN(date.getTime())) return date.toISOString()
-  }
-
-  return value
-}
-
-// =============================================================================
-// Optimized File Reading
-// =============================================================================
-
-/**
- * Read only the frontmatter from a file, optimized for large files.
- *
- * Reads incrementally until we find the closing ---, avoiding reading
- * the entire file into memory.
- *
- * @param path - Path to the markdown file
- * @param maxBytes - Maximum bytes to read looking for frontmatter (default 8KB)
- * @returns The parsed frontmatter, or null if not found
- */
-export async function readFrontmatter(
-  path: string,
-  maxBytes = 8192
-): Promise<Record<string, unknown> | null> {
-  try {
-    const file = Bun.file(path)
-    const size = file.size
-
-    // Read up to maxBytes or file size
-    const bytesToRead = Math.min(maxBytes, size)
-    const buffer = await file.slice(0, bytesToRead).text()
-
-    return parseFrontmatter(buffer)
-  } catch {
-    return null
-  }
-}
-
-/**
- * Read frontmatter and return the offset where body starts.
- * Useful when you need both frontmatter and body.
- *
- * @param path - Path to the markdown file
- * @returns Object with frontmatter and body start offset
- */
-export async function readFrontmatterWithOffset(
-  path: string
-): Promise<{ frontmatter: Record<string, unknown> | null; bodyOffset: number }> {
-  try {
-    const file = Bun.file(path)
-    const content = await file.text()
-
-    const frontmatter = parseFrontmatter(content)
-    const bodyOffset = getFrontmatterEndOffset(content)
-
-    return { frontmatter, bodyOffset }
-  } catch {
-    return { frontmatter: null, bodyOffset: 0 }
-  }
-}