@pathmx/core 0.5.0

package/schema/standard.ts

@@ -0,0 +1,226 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>
+}
+
+export function isStandardSchema(value: unknown): value is StandardSchemaV1 {
+  if (
+    value == null ||
+    (typeof value !== "object" && typeof value !== "function")
+  ) {
+    return false
+  }
+  const standard = (value as { ["~standard"]?: unknown })["~standard"]
+  if (standard == null || typeof standard !== "object") return false
+  const props = standard as { version?: unknown; validate?: unknown }
+  return props.version === 1 && typeof props.validate === "function"
+}
+
+/** The orthogonal Standard JSON Schema v1 discovery interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>
+}
+
+export declare namespace StandardJSONSchemaV1 {
+  export interface Props<Input = unknown, Output = Input> {
+    readonly version: 1
+    readonly vendor: string
+    readonly types?: Types<Input, Output> | undefined
+    readonly jsonSchema: Converter
+  }
+
+  export interface Converter {
+    readonly input: (options: Options) => Readonly<Record<string, unknown>>
+    readonly output: (options: Options) => Readonly<Record<string, unknown>>
+  }
+
+  export type Target =
+    "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string)
+
+  export interface Options {
+    readonly target: Target
+    readonly libraryOptions?: Record<string, unknown> | undefined
+  }
+
+  export interface Types<Input = unknown, Output = Input> {
+    readonly input: Input
+    readonly output: Output
+  }
+
+  export type InferInput<Schema extends StandardJSONSchemaV1> = NonNullable<
+    Schema["~standard"]["types"]
+  >["input"]
+
+  export type InferOutput<Schema extends StandardJSONSchemaV1> = NonNullable<
+    Schema["~standard"]["types"]
+  >["output"]
+}
+
+/** PathMX data combines validation and transport-safe structural discovery. */
+export type PathMXDataSchema<
+  Input = unknown,
+  Output = Input,
+> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>
+
+export function isStandardJsonSchema(
+  value: unknown,
+): value is StandardJSONSchemaV1 {
+  if (
+    value == null ||
+    (typeof value !== "object" && typeof value !== "function")
+  ) {
+    return false
+  }
+  const jsonSchema = (value as Partial<StandardJSONSchemaV1>)["~standard"]
+    ?.jsonSchema
+  return (
+    jsonSchema != null &&
+    typeof jsonSchema.input === "function" &&
+    typeof jsonSchema.output === "function"
+  )
+}
+
+function isJsonSchemaObject(
+  value: unknown,
+): value is Readonly<Record<string, unknown>> {
+  return value != null && typeof value === "object" && !Array.isArray(value)
+}
+
+const requiredJsonSchemas = new WeakMap<
+  object,
+  Partial<Record<"input" | "output", Readonly<Record<string, unknown>>>>
+>()
+
+/** Convert an installed PathMX data schema or fail registration with context. */
+export function requireStandardJsonSchema(
+  schema: unknown,
+  direction: "input" | "output",
+  subject: string,
+) {
+  if (!isStandardSchema(schema) || !isStandardJsonSchema(schema)) {
+    throw new Error(
+      `${subject} must implement Standard Schema and Standard JSON Schema v1.`,
+    )
+  }
+  const cached = requiredJsonSchemas.get(schema)?.[direction]
+  if (cached) return cached
+  let converted: unknown
+  try {
+    converted = schema["~standard"].jsonSchema[direction]({
+      target: "draft-2020-12",
+    })
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error)
+    throw new Error(`${subject} ${direction} JSON Schema failed: ${detail}`)
+  }
+  if (!isJsonSchemaObject(converted)) {
+    throw new Error(`${subject} ${direction} JSON Schema must be an object.`)
+  }
+  const frozen = Object.freeze(converted)
+  const directions = requiredJsonSchemas.get(schema) ?? {}
+  directions[direction] = frozen
+  requiredJsonSchemas.set(schema, directions)
+  return frozen
+}
+
+export function standardJsonSchema(
+  schema: StandardSchemaV1 | undefined,
+  direction: "input" | "output",
+) {
+  const converter = (schema as Partial<StandardJSONSchemaV1> | undefined)?.[
+    "~standard"
+  ]?.jsonSchema?.[direction]
+  if (!converter) return
+  try {
+    return Object.freeze(converter({ target: "draft-2020-12" }))
+  } catch {
+    return
+  }
+}
+
+export function formatSchemaIssues(
+  issues: ReadonlyArray<StandardSchemaV1.Issue>,
+) {
+  return issues
+    .map((issue) => {
+      const path = issue.path
+        ?.map((segment) =>
+          String(typeof segment === "object" ? segment.key : segment),
+        )
+        .join(".")
+      return path ? `${path}: ${issue.message}` : issue.message
+    })
+    .join("; ")
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1
+    /** The vendor name of the schema library. */
+    readonly vendor: string
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+      options?: StandardSchemaV1.Options | undefined,
+    ) => Result<Output> | Promise<Result<Output>>
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined
+  }
+
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult
+
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined
+  }
+
+  export interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined
+  }
+
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>
+  }
+
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined
+  }
+
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey
+  }
+
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input
+    /** The output type of the schema. */
+    readonly output: Output
+  }
+
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema["~standard"]["types"]
+  >["input"]
+
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema["~standard"]["types"]
+  >["output"]
+}

package/server/context.ts

@@ -0,0 +1,94 @@
+import { AccessDeniedError } from "../authority/access.ts"
+import { createTransaction } from "../actions/transaction.ts"
+import type { Engine } from "../host/engine.ts"
+import type { ServerContext, ServerRenderOptions } from "../plugins/types.ts"
+import type { Source } from "../source/index.ts"
+import { principalFor, type CredentialSession } from "../authority/model.ts"
+import type { View } from "../view/model.ts"
+import { renderPage } from "../host/render.ts"
+import { pageNotFound, requestScheme } from "./page.ts"
+
+/** @internal Bind one portable handler to its owning plugin and Engine. */
+export function createServerContext(
+  app: Engine,
+  plugin: string,
+  path: string,
+  request: Request,
+  url: URL,
+): ServerContext {
+  let resolvedSession: Promise<CredentialSession> | undefined
+  let resolvedView: Promise<View> | undefined
+  const session = () => (resolvedSession ??= app.resolveCredentials(request))
+  const view = () =>
+    (resolvedView ??= session().then((value) => app.view(value)))
+  const appContext = app.appContext(plugin)
+  const resolveSource = (input: Source | string) =>
+    typeof input === "string" ? appContext.sources.get(input) : input
+
+  return Object.freeze({
+    request,
+    url,
+    path,
+    plugin,
+    log: appContext.log,
+    runtime: appContext.runtime,
+    database: appContext.database,
+    graph: appContext.graph,
+    source(idOrPath) {
+      return appContext.sources.get(idOrPath)
+    },
+    sources() {
+      return appContext.sources.all()
+    },
+    resolve(pathname) {
+      return appContext.sources.resolve(pathname)
+    },
+    isPublic(target) {
+      return appContext.access.read({ type: "anonymous" }, target) === "public"
+    },
+    session,
+    view,
+    async readAccess(target) {
+      const credentials = await session()
+      return appContext.access.read(principalFor(credentials), target)
+    },
+    onSync(listener) {
+      return app.onSync(listener)
+    },
+    async render(input, options: ServerRenderOptions = {}) {
+      const source = resolveSource(input)
+      if (!source) return pageNotFound()
+      const credentials = await session()
+      return renderPage(app, credentials, principalFor(credentials), source, {
+        ...options,
+        scheme: requestScheme(request),
+      })
+    },
+    async mutate(run) {
+      const credentials = await session()
+      if (credentials.type !== "authenticated") {
+        throw new AccessDeniedError("authentication-required")
+      }
+      const result = await app.commitPrepared(async () => {
+        const transaction = createTransaction(app, credentials.actor)
+        await run(transaction)
+        return transaction.changeSet()
+      })
+      if (result.applied.length) {
+        app.log.info("server.mutation", {
+          plugin,
+          method: request.method,
+          path: url.pathname,
+          changes: result.applied.length,
+        })
+      }
+      return result
+    },
+    mutateAsAgent(admission, run) {
+      return app.runAgentJob(admission, run)
+    },
+    handleCredentials() {
+      return app.credentialRequest(request)
+    },
+  })
+}

package/server/css-imports.ts

@@ -0,0 +1,66 @@
+import { posix } from "node:path"
+
+const CSS_IMPORT =
+  /@import\s+(?:url\(\s*(?:"([^"]+)"|'([^']+)'|([^'"\s)]+))\s*\)|"([^"]+)"|'([^']+)')/gi
+const EXTERNAL = /^(?:[a-z][a-z\d+.-]*:|\/\/|#)/i
+
+function importedPath(importer: string, specifier: string) {
+  const raw = specifier.split(/[?#]/, 1)[0]
+  if (!raw || EXTERNAL.test(raw)) return
+  const path = posix.resolve(posix.dirname(importer), raw)
+  return path.endsWith(".css") ? path : undefined
+}
+
+function cssImports(importer: string, css: string) {
+  const imports = new Set<string>()
+  for (const match of css.matchAll(CSS_IMPORT)) {
+    const specifier = match.slice(1).find((value) => value !== undefined)
+    if (!specifier) continue
+    const path = importedPath(importer, specifier)
+    if (path) imports.add(path)
+  }
+  return imports
+}
+
+/** Internal reverse index for native authored CSS imports. */
+export class CssImportIndex {
+  private dependencies = new Map<string, Set<string>>()
+  private dependents = new Map<string, Set<string>>()
+
+  replace(importer: string, css?: string) {
+    for (const dependency of this.dependencies.get(importer) ?? []) {
+      const importers = this.dependents.get(dependency)
+      importers?.delete(importer)
+      if (!importers?.size) this.dependents.delete(dependency)
+    }
+
+    if (css === undefined) {
+      this.dependencies.delete(importer)
+      return
+    }
+
+    const imports = cssImports(importer, css)
+    this.dependencies.set(importer, imports)
+    for (const dependency of imports) {
+      let importers = this.dependents.get(dependency)
+      if (!importers) {
+        importers = new Set()
+        this.dependents.set(dependency, importers)
+      }
+      importers.add(importer)
+    }
+  }
+
+  affected(path: string) {
+    const affected = new Set([path])
+    const queue = [path]
+    for (const dependency of queue) {
+      for (const importer of this.dependents.get(dependency) ?? []) {
+        if (affected.has(importer)) continue
+        affected.add(importer)
+        queue.push(importer)
+      }
+    }
+    return affected
+  }
+}