Platform Quickstart

npm install @phosra/gatekeeper

// src/lib/phosra.ts
import { createPlatform } from "@phosra/gatekeeper"
import { pool } from "@/db"

export const phosra = createPlatform({
  credential: process.env.PHOSRA_CREDENTIAL!,
  humanRecovery: {
    signInPath: "/sign-in",
    createProfilePath: "/profiles/new",
  },
  adapter: {
    database: pool,
    authorizedProviders: ["did:ocss:custo"],

    resolveAccount: async (request) => {
      const session = await sessionFrom(request)
      if (!session) return null
      return {
        accountId: session.accountId,
        profiles: await childProfilesFor(session.accountId),
        // Each profile: { id, displayName, displayHint? }
      }
    },

    apply: async ({ selectedProfileId, profile, idempotencyKey }) => {
      await applyParentalControls({ selectedProfileId, profile, idempotencyKey })
    },

    observe: async ({ selectedProfileId, profile }, evidence) => {
      const actual = await readPersistedControls(selectedProfileId)
      return profile.rules.map((rule) => {
        const control = actual.get(rule.category)
        if (!control) return evidence.refused(rule, "unsupported")
        if (!control.enabled) return evidence.degraded(rule, "platform-conflict")
        return evidence.applied(rule, {
          method: "gate",
          sideEffectId: control.id,
        })
      })
    },

    release: async ({ selectedProfileId, idempotencyKey }) => {
      await removePhosraControls({ selectedProfileId, idempotencyKey })
    },

    observeRelease: async ({ selectedProfileId }, evidence) => {
      const removal = await readRemoval(selectedProfileId)
      return evidence.released({ sideEffectId: removal.id })
    },
  },
})

// app/api/phosra/[...phosra]/route.ts
import { phosra } from "@/lib/phosra"

export const { GET, POST } = phosra.next.handlers()

const expected = `${applicationOrigin}/api/phosra/delivery`
const discovery = await fetch(
  `${census}/api/v1/providers/${encodeURIComponent(platformDid)}/connect`,
).then((response) => {
  if (!response.ok) throw new Error(`Platform discovery failed (${response.status})`)
  return response.json()
})

if (discovery.connect_url !== expected) {
  throw new Error(`Expected ${expected}, received ${discovery.connect_url ?? "no connect_url"}`)
}

// phosra-worker.ts
import { phosra } from "@/lib/phosra"

await phosra.ready()
const shutdown = new AbortController()
process.once("SIGTERM", () => shutdown.abort())
process.once("SIGINT", () => shutdown.abort())

const worker = phosra.worker.start({
  signal: shutdown.signal,
  onError: (error) => console.error("Phosra worker pass failed", error),
})
await worker.drain()

const topology = await phosra.readTopology()