clone/opencode
1
0
Fork 0
mirror of https://github.com/anomalyco/opencode.git synced 2026-04-24 06:45:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor API

Browse Source
This commit is contained in:
James Long
2026-03-22 16:03:58 -04:00
parent 2385bd3ce1
commit c05f18927e
36 changed files with 3193 additions and 2474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
packages/opencode/migration/20260318163842_events/snapshot.json
View File

@@ -2,9 +2,7 @@
"version": "7",
"dialect": "sqlite",
"id": "64c94495-3f7d-4169-a078-2df22ca80057",
"prevIds": [
"fb311f30-9948-4131-b15c-7d308478a878"
],
"prevIds": ["fb311f30-9948-4131-b15c-7d308478a878"],
"ddl": [
{
"name": "account_state",
@@ -969,13 +967,9 @@
"table": "event"
},
{
"columns": [
"active_account_id"
],
"columns": ["active_account_id"],
"tableTo": "account",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "SET NULL",
"nameExplicit": false,
@@ -984,13 +978,9 @@
"table": "account_state"
},
{
"columns": [
"project_id"
],
"columns": ["project_id"],
"tableTo": "project",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -999,13 +989,9 @@
"table": "workspace"
},
{
"columns": [
"session_id"
],
"columns": ["session_id"],
"tableTo": "session",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1014,13 +1000,9 @@
"table": "message"
},
{
"columns": [
"message_id"
],
"columns": ["message_id"],
"tableTo": "message",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1029,13 +1011,9 @@
"table": "part"
},
{
"columns": [
"project_id"
],
"columns": ["project_id"],
"tableTo": "project",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1044,13 +1022,9 @@
"table": "permission"
},
{
"columns": [
"project_id"
],
"columns": ["project_id"],
"tableTo": "project",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1059,13 +1033,9 @@
"table": "session"
},
{
"columns": [
"session_id"
],
"columns": ["session_id"],
"tableTo": "session",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1074,13 +1044,9 @@
"table": "todo"
},
{
"columns": [
"session_id"
],
"columns": ["session_id"],
"tableTo": "session",
"columnsTo": [
"id"
],
"columnsTo": ["id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1089,13 +1055,9 @@
"table": "session_share"
},
{
"columns": [
"aggregate_id"
],
"columns": ["aggregate_id"],
"tableTo": "event_sequence",
"columnsTo": [
"aggregate_id"
],
"columnsTo": ["aggregate_id"],
"onUpdate": "NO ACTION",
"onDelete": "CASCADE",
"nameExplicit": false,
@@ -1104,119 +1066,91 @@
"table": "event"
},
{
"columns": [
"email",
"url"
],
"columns": ["email", "url"],
"nameExplicit": false,
"name": "control_account_pk",
"entityType": "pks",
"table": "control_account"
},
{
"columns": [
"session_id",
"position"
],
"columns": ["session_id", "position"],
"nameExplicit": false,
"name": "todo_pk",
"entityType": "pks",
"table": "todo"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "account_state_pk",
"table": "account_state",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "account_pk",
"table": "account",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "workspace_pk",
"table": "workspace",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "project_pk",
"table": "project",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "message_pk",
"table": "message",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "part_pk",
"table": "part",
"entityType": "pks"
},
{
"columns": [
"project_id"
],
"columns": ["project_id"],
"nameExplicit": false,
"name": "permission_pk",
"table": "permission",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "session_pk",
"table": "session",
"entityType": "pks"
},
{
"columns": [
"session_id"
],
"columns": ["session_id"],
"nameExplicit": false,
"name": "session_share_pk",
"table": "session_share",
"entityType": "pks"
},
{
"columns": [
"aggregate_id"
],
"columns": ["aggregate_id"],
"nameExplicit": false,
"name": "event_sequence_pk",
"table": "event_sequence",
"entityType": "pks"
},
{
"columns": [
"id"
],
"columns": ["id"],
"nameExplicit": false,
"name": "event_pk",
"table": "event",
@@ -1322,4 +1256,4 @@
}
],
"renames": []
}
}

3
packages/opencode/src/bus/bus-event.ts
View File

@@ -17,8 +17,7 @@ export namespace BusEvent {
export function payloads() {
return z
.discriminatedUnion(
"type",
.union(
registry
.entries()
.map(([type, def]) => {

29
packages/opencode/src/bus/index.ts
View File

@@ -2,12 +2,21 @@ import z from "zod"
import { Log } from "../util/log"
import { Instance } from "../project/instance"
import { BusEvent } from "./bus-event"
import { SyncEvent } from "../sync"
import { GlobalBus } from "./global"
export namespace Bus {
const log = Log.create({ service: "bus" })
type Subscription = (event: any) => void
type SubscribableProperties<Def> = Def extends { data: infer Data }
? z.infer<Data>
: Def extends { properties: infer Properties }
? z.infer<Properties>
: never
type SubscribableDefinition = BusEvent.Definition | SyncEvent.Definition
export const InstanceDisposed = BusEvent.define(
"server.instance.disposed",
z.object({
@@ -63,19 +72,16 @@ export namespace Bus {
return Promise.all(pending)
}
export function subscribe<Definition extends BusEvent.Definition>(
def: Definition,
callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
export function subscribe<Def extends SubscribableDefinition>(
def: Def,
callback: (event: { type: Def["type"]; properties: SubscribableProperties<Def> }) => void,
) {
return raw(def.type, callback)
}
export function once<Definition extends BusEvent.Definition>(
export function once<Definition extends SubscribableDefinition>(
def: Definition,
callback: (event: {
type: Definition["type"]
properties: z.infer<Definition["properties"]>
}) => "done" | undefined,
callback: (event: { type: Definition["type"]; properties: SubscribableProperties<Definition> }) => "done" | undefined,
) {
const unsub = subscribe(def, (event) => {
if (callback(event)) unsub()
@@ -102,4 +108,11 @@ export namespace Bus {
match.splice(index, 1)
}
}
export function fromSyncDefinition(def: SyncEvent.Definition) {
return {
type: def.type,
properties: def.data,
}
}
}

5
packages/opencode/src/cli/cmd/github.ts
View File

@@ -26,6 +26,7 @@ import type { SessionID } from "../../session/schema"
import { MessageID, PartID } from "../../session/schema"
import { Provider } from "../../provider/provider"
import { Bus } from "../../bus"
import { SyncEvent } from "../../sync"
import { MessageV2 } from "../../session/message-v2"
import { SessionPrompt } from "@/session/prompt"
import { setTimeout as sleep } from "node:timers/promises"
@@ -891,9 +892,9 @@ export const GithubRunCommand = cmd({
let text = ""
Bus.subscribe(MessageV2.Event.PartUpdated, (evt) => {
if (evt.properties.data.part.sessionID !== session.id) return
if (evt.properties.part.sessionID !== session.id) return
//if (evt.properties.part.messageID === messageID) return
const part = evt.properties.data.part
const part = evt.properties.part
if (part.type === "tool" && part.state.status === "completed") {
const [tool, color] = TOOL[part.tool] ?? [part.tool, UI.Style.TEXT_INFO_BOLD]

4
packages/opencode/src/cli/cmd/tui/app.tsx
View File

@@ -699,7 +699,7 @@ function App() {
})
})
sdk.event.on(SessionApi.Event.Deleted.type, (evt) => {
sdk.event.on("session.deleted", (evt) => {
if (route.data.type === "session" && route.data.sessionID === evt.properties.info.id) {
route.navigate({ type: "home" })
toast.show({
@@ -709,7 +709,7 @@ function App() {
}
})
sdk.event.on(SessionApi.Event.Error.type, (evt) => {
sdk.event.on("session.error", (evt) => {
const error = evt.properties.error
if (error && typeof error === "object" && error.name === "MessageAbortedError") return
const message = (() => {

37
packages/opencode/src/server/projectors.ts
View File

@@ -1,6 +1,39 @@
import z from "zod"
import sessionProjectors from "../session/projectors"
import { SyncEvent } from "../sync"
import { SyncEvent } from "@/sync"
import { Session } from "@/session"
import { SessionID } from "@/session/schema"
let initialized = false
export function initProjectors() {
SyncEvent.init(sessionProjectors)
if (initialized) {
return
}
initialized = true
SyncEvent.init({
projectors: sessionProjectors,
convertDefinition: (type, data) => {
if (type === "session.updated") {
return z.object({
sessionID: SessionID.zod,
info: Session.Info,
})
}
return data
},
convertEvent: (type, data) => {
if (type === "session.updated") {
const sessionID = (data as z.infer<typeof Session.Event.Updated.data>).sessionID
return {
sessionID: SessionID.zod,
info: Session.get(sessionID),
}
}
return data
},
})
}
initProjectors()

15
packages/opencode/src/server/routes/event.ts
View File

@@ -6,7 +6,6 @@ import { BusEvent } from "@/bus/bus-event"
import { Bus } from "@/bus"
import { lazy } from "../../util/lazy"
import { AsyncQueue } from "../../util/queue"
import { Instance } from "@/project/instance"
const log = Log.create({ service: "server" })
@@ -53,13 +52,6 @@ export const EventRoutes = lazy(() =>
)
}, 10_000)
const unsub = Bus.subscribeAll((event) => {
q.push(JSON.stringify(event))
if (event.type === Bus.InstanceDisposed.type) {
stop()
}
})
const stop = () => {
if (done) return
done = true
@@ -69,6 +61,13 @@ export const EventRoutes = lazy(() =>
log.info("event disconnected")
}
const unsub = Bus.subscribeAll((event) => {
q.push(JSON.stringify(event))
if (event.type === Bus.InstanceDisposed.type) {
stop()
}
})
stream.onAbort(stop)
try {

145
packages/opencode/src/server/routes/global.ts
View File

@@ -1,9 +1,9 @@
import { Hono } from "hono"
import { describeRoute, validator, resolver } from "hono-openapi"
import { Hono, type Context } from "hono"
import { describeRoute, resolver, validator } from "hono-openapi"
import { streamSSE } from "hono/streaming"
import z from "zod"
import { Bus } from "../../bus"
import { BusEvent } from "@/bus/bus-event"
import { SyncEvent } from "@/sync"
import { GlobalBus } from "@/bus/global"
import { AsyncQueue } from "@/util/queue"
import { Instance } from "../../project/instance"
@@ -17,6 +17,56 @@ const log = Log.create({ service: "server" })
export const GlobalDisposedEvent = BusEvent.define("global.disposed", z.object({}))
async function streamEvents(c: Context, subscribe: (q: AsyncQueue<string | null>) => () => void) {
return streamSSE(c, async (stream) => {
const q = new AsyncQueue<string | null>()
let done = false
q.push(
JSON.stringify({
payload: {
type: "server.connected",
properties: {},
},
}),
)
// Send heartbeat every 10s to prevent stalled proxy streams.
const heartbeat = setInterval(() => {
q.push(
JSON.stringify({
payload: {
type: "server.heartbeat",
properties: {},
},
}),
)
}, 10_000)
const stop = () => {
if (done) return
done = true
clearInterval(heartbeat)
unsub()
q.push(null)
log.info("global event disconnected")
}
const unsub = subscribe(q)
stream.onAbort(stop)
try {
for await (const data of q) {
if (data === null) return
await stream.writeSSE({ data })
}
} finally {
stop()
}
})
}
export const GlobalRoutes = lazy(() =>
new Hono()
.get(
@@ -70,55 +120,56 @@ export const GlobalRoutes = lazy(() =>
log.info("global event connected")
c.header("X-Accel-Buffering", "no")
c.header("X-Content-Type-Options", "nosniff")
return streamSSE(c, async (stream) => {
const q = new AsyncQueue<string | null>()
let done = false
q.push(
JSON.stringify({
payload: {
type: "server.connected",
properties: {},
},
}),
)
// Send heartbeat every 10s to prevent stalled proxy streams.
const heartbeat = setInterval(() => {
q.push(
JSON.stringify({
payload: {
type: "server.heartbeat",
properties: {},
},
}),
)
}, 10_000)
return streamEvents(c, (q) => {
async function handler(event: any) {
q.push(JSON.stringify(event))
}
GlobalBus.on("event", handler)
const stop = () => {
if (done) return
done = true
clearInterval(heartbeat)
GlobalBus.off("event", handler)
q.push(null)
log.info("event disconnected")
}
stream.onAbort(stop)
try {
for await (const data of q) {
if (data === null) return
await stream.writeSSE({ data })
}
} finally {
stop()
}
return () => GlobalBus.off("event", handler)
})
},
)
.get(
"/sync-event",
describeRoute({
summary: "Subscribe to global sync events",
description: "Get global sync events",
operationId: "global.sync-event.subscribe",
responses: {
200: {
description: "Event stream",
content: {
"text/event-stream": {
schema: resolver(
z
.object({
payload: SyncEvent.payloads(),
})
.meta({
ref: "SyncEvent",
}),
),
},
},
},
},
}),
async (c) => {
log.info("global sync event connected")
c.header("X-Accel-Buffering", "no")
c.header("X-Content-Type-Options", "nosniff")
return streamEvents(c, (q) => {
return SyncEvent.subscribeAll(({ def, event }) => {
q.push(
JSON.stringify({
payload: {
...event,
type: SyncEvent.versionedType(def.type, def.version),
},
}),
)
})
})
},
)

27
packages/opencode/src/session/index.ts
View File

@@ -185,36 +185,28 @@ export namespace Session {
export const Event = {
Created: SyncEvent.define({
type: "session.created",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
info: Info,
}),
}),
Shared: SyncEvent.define({
type: "session.shared",
version: "v1",
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
url: z.string().optional(),
}),
}),
Updated: SyncEvent.define({
type: "session.updated",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
info: Info.partial().extend({
share: Info.shape.share.unwrap().partial().optional(),
time: Info.shape.time.partial().optional(),
}),
}),
}),
Deleted: SyncEvent.define({
type: "session.deleted",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
@@ -333,14 +325,11 @@ export namespace Session {
SyncEvent.run(Event.Created, { sessionID: result.id, info: result })
const cfg = await Config.get()
if (!result.parentID && (Flag.OPENCODE_AUTO_SHARE || cfg.share === "auto"))
if (!result.parentID && (Flag.OPENCODE_AUTO_SHARE || cfg.share === "auto")) {
share(result.id).catch(() => {
// Silently ignore sharing errors during session creation
})
// Bus.publish(Event.Updated, {
// id: result.id,
// info: result,
// })
}
return result
}
@@ -365,7 +354,7 @@ export namespace Session {
const { ShareNext } = await import("@/share/share-next")
const share = await ShareNext.create(id)
SyncEvent.run(Event.Shared, { sessionID: id, url: share.url })
SyncEvent.run(Event.Updated, { sessionID: id, info: { share: { url: share.url } } })
return share
})
@@ -375,7 +364,7 @@ export namespace Session {
const { ShareNext } = await import("@/share/share-next")
await ShareNext.remove(id)
SyncEvent.run(Event.Shared, { sessionID: id, url: undefined })
SyncEvent.run(Event.Updated, { sessionID: id, info: { share: { url: undefined } } })
})
export const setTitle = fn(

8
packages/opencode/src/session/message-v2.ts
View File

@@ -449,7 +449,7 @@ export namespace MessageV2 {
export const Event = {
Updated: SyncEvent.define({
type: "message.updated",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
@@ -458,7 +458,7 @@ export namespace MessageV2 {
}),
Removed: SyncEvent.define({
type: "message.removed",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
@@ -467,7 +467,7 @@ export namespace MessageV2 {
}),
PartUpdated: SyncEvent.define({
type: "message.part.updated",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,
@@ -487,7 +487,7 @@ export namespace MessageV2 {
),
PartRemoved: SyncEvent.define({
type: "message.part.removed",
version: "v1",
version: 1,
aggregate: "sessionID",
schema: z.object({
sessionID: SessionID.zod,

11
packages/opencode/src/session/projectors.ts
View File

@@ -5,9 +5,7 @@ import { MessageV2 } from "./message-v2"
import { SessionTable, MessageTable, PartTable } from "./session.sql"
import { ProjectTable } from "../project/project.sql"
export type DeepPartial<T> = {
[K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
}
export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T
function grab<T extends object, K1 extends keyof T, X>(
obj: T,
@@ -73,14 +71,9 @@ export default [
SyncEvent.project(Session.Event.Updated, (db, data) => {
const info = data.info
const row = db.update(SessionTable).set(toPartialRow(info)).where(eq(SessionTable.id, data.sessionID)).returning().get()
if (!row) throw new NotFoundError({ message: `Session not found: ${data.sessionID}` })
}),
SyncEvent.project(Session.Event.Shared, (db, data) => {
const row = db
.update(SessionTable)
.set({ share_url: data.url })
.set(toPartialRow(info))
.where(eq(SessionTable.id, data.sessionID))
.returning()
.get()

10
packages/opencode/src/share/share-next.ts
View File

@@ -66,7 +66,7 @@ export namespace ShareNext {
export async function init() {
if (disabled) return
Bus.subscribe(Session.Event.Updated, async (evt) => {
const session = await Session.get(evt.properties.data.sessionID)
const session = await Session.get(evt.properties.sessionID)
await sync(session.id, [
{
@@ -76,11 +76,11 @@ export namespace ShareNext {
])
})
Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
const info = evt.properties.data.info
const info = evt.properties.info
await sync(info.sessionID, [
{
type: "message",
data: evt.properties.data.info,
data: evt.properties.info,
},
])
if (info.role === "user") {
@@ -93,10 +93,10 @@ export namespace ShareNext {
}
})
Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
await sync(evt.properties.data.part.sessionID, [
await sync(evt.properties.part.sessionID, [
{
type: "part",
data: evt.properties.data.part,
data: evt.properties.part,
},
])
})

1
packages/opencode/src/sync/.#README.md Symbolic link
View File

@@ -0,0 +1 @@
james@james-6.local.34647:1773877465

123
packages/opencode/src/sync/index.ts
View File

@@ -1,61 +1,88 @@
import z from "zod"
import type { ZodObject } from "zod"
import { Identifier } from "@/id/id"
import { BusEvent } from "@/bus/bus-event"
import { EventEmitter } from "events"
import { Database, eq } from "@/storage/db"
import { Bus } from "@/bus"
import { Bus as ProjectBus } from "@/bus"
import { BusEvent } from "@/bus/bus-event"
import { EventSequenceTable, EventTable } from "./event.sql"
import { EventID } from "./schema"
export namespace SyncEvent {
export type Definition = {
type: string
properties: ZodObject<{ id: z.ZodString; seq: z.ZodNumber; aggregateID: z.ZodString; data: z.ZodObject }>
version: string
version: number
aggregate: string
data: z.ZodObject
}
export type Event<Def extends Definition = Definition> = {
id: string
seq: number
aggregateID: string
data: z.infer<Def["properties"]>["data"]
data: z.infer<Def["data"]>
}
export type SerializedEvent<Def extends Definition = Definition> = Event<Def> & { type: string }
type ProjectorFunc = (db: Database.TxOrDb, data: unknown) => void
const registry = new Map<string, Definition>()
export const registry = new Map<string, Definition>()
let projectors: Map<Definition, ProjectorFunc> | undefined
const versions = new Map<string, number>()
let frozen = false
let convertEvent: ((type: string, event: Event["data"]) => Record<string, unknown>) | undefined
export function init(pjs: Array<[Definition, ProjectorFunc]>) {
projectors = new Map(pjs)
const Bus = new EventEmitter<{ event: [{ def: Definition; event: Event }] }>()
export function init(input: {
projectors: Array<[Definition, ProjectorFunc]>
convertDefinition?: (type: string, data: ZodObject) => ZodObject
convertEvent?: Exclude<typeof convertEvent, undefined>
}) {
projectors = new Map(input.projectors)
// Install all the latest event defs to the bus. We only ever emit
// latest versions from code, and keep around old versions for
// replaying. Replaying does not go through the bus, and it
// simplifies the bus to only use unversioned latest events
for (let [type, version] of versions.entries()) {
let def = registry.get(versionedType(type, version))!
let data = def.data
BusEvent.define(def.type, input.convertDefinition ? input.convertDefinition(type, data) : data)
}
// Freeze the system so it clearly errors if events are defined
// after `init` which would cause bugs
frozen = true
convertEvent = input.convertEvent
}
export function versionedName(type: string, version?: string) {
export function versionedType<A extends string>(type: A): A
export function versionedType<A extends string, B extends number>(type: A, version: B): `${A}/${B}`
export function versionedType(type: string, version?: number) {
return version ? `${type}.${version}` : type
}
export function define<
Type extends string,
Version extends string,
Agg extends string,
Schema extends ZodObject<Record<Agg, z.ZodType<string>>>,
>(input: { type: Type; version: Version; aggregate: Agg; schema: Schema }) {
>(input: { type: Type; version: number; aggregate: Agg; schema: Schema }) {
if (frozen) {
throw new Error("Error defining sync event: sync system has been frozen")
}
const def = {
type: input.type,
properties: z.object({
id: Identifier.schema("event"),
seq: z.number(),
aggregateID: z.string(),
data: input.schema,
}),
version: input.version,
data: input.schema,
aggregate: input.aggregate,
}
registry.set(versionedName(def.type, def.version), def)
BusEvent.define(versionedName(def.type, def.version), def.properties)
versions.set(def.type, Math.max(def.version, versions.get(def.type) || 0))
registry.set(versionedType(def.type, def.version), def)
return def
}
@@ -96,7 +123,7 @@ export namespace SyncEvent {
id: input.id,
seq: input.seq,
aggregate_id: input.aggregateID,
name: versionedName(def.type, def.version),
name: def.type,
data: input.data as Record<string, unknown>,
})
.run()
@@ -128,6 +155,7 @@ export namespace SyncEvent {
throw new Error(`Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`)
}
console.log("seq", event.seq)
process(def, event)
}
@@ -136,15 +164,19 @@ export namespace SyncEvent {
// This should never happen: we've enforced it via typescript in
// the definition
if (agg == null) {
throw new Error(`SyncEvent: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
}
// if (!latest || def.version !== latest.version) {
// throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
// }
// Note that this is an "immediate" transaction which is critical.
// We need to make sure we can safely read and write with nothing
// else changing the data from under us
Database.transaction(
(tx) => {
const id = Identifier.ascending("workspace")
const id = EventID.ascending()
const row = tx
.select({ seq: EventSequenceTable.seq })
.from(EventSequenceTable)
@@ -152,11 +184,22 @@ export namespace SyncEvent {
.get()
const seq = row?.seq != null ? row.seq + 1 : 0
process(def, { id, seq, aggregateID: agg, data })
const event = { id, seq, aggregateID: agg, data }
process(def, event)
Database.effect(() => {
const versionedDef = { ...def, type: versionedName(def.type, def.version) }
Bus.publish(versionedDef, { id, seq, aggregateID: agg, data } as z.output<Def["properties"]>)
Bus.emit("event", {
def,
event,
})
ProjectBus.publish(
{
type: def.type,
properties: def.data,
},
convertEvent ? convertEvent(def.type, event.data) : event.data,
)
})
},
{
@@ -164,4 +207,32 @@ export namespace SyncEvent {
},
)
}
export function subscribeAll(handler: (event: { def: Definition; event: Event }) => void) {
Bus.on("event", handler)
return () => Bus.off("event", handler)
}
export function payloads() {
return z
.union(
registry
.entries()
.map(([type, def]) => {
return z
.object({
type: z.literal(type),
aggregate: z.literal(def.aggregate),
data: def.data,
})
.meta({
ref: "SyncEvent" + "." + def.type,
})
})
.toArray() as any,
)
.meta({
ref: "SyncEvent",
})
}
}

14
packages/opencode/src/sync/schema.ts Normal file
View File

@@ -0,0 +1,14 @@
import { Schema } from "effect"
import z from "zod"
import { Identifier } from "@/id/id"
import { withStatics } from "@/util/schema"
export const EventID = Schema.String.pipe(
Schema.brand("EventID"),
withStatics((s) => ({
make: (id: string) => s.makeUnsafe(id),
ascending: (id?: string) => s.makeUnsafe(Identifier.ascending("event", id)),
zod: Identifier.schema("event").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
})),
)

20
packages/opencode/src/test-replicate.ts
View File

@@ -24,8 +24,9 @@ Log.init({ print: true, dev: true, level: "DEBUG" })
const { Database } = await import("@/storage/db")
const { SyncEvent } = await import("@/sync")
const { parseSSE } = await import("@/control-plane/sse")
const { initProjectors } = await import("@/server/projectors")
const url = process.argv[2] || "http://127.0.0.1:4096/global/event"
const url = process.argv[2] || "http://127.0.0.1:4096/global/sync-event"
const ac = new AbortController()
process.on("SIGINT", () => ac.abort())
@@ -37,6 +38,8 @@ async function run() {
signal: ac.signal,
})
console.log(res.statusText)
if (!res.ok) {
console.error("failed to connect:", res.status, await res.text())
process.exit(1)
@@ -48,22 +51,23 @@ async function run() {
}
console.log("connected, listening for events...\n")
const { default: sessionProjectors } = await import("@/session/projectors")
SyncEvent.init(sessionProjectors)
initProjectors()
Database.Client()
await parseSSE(res.body, ac.signal, (event: any) => {
// console.log("[sse]", JSON.stringify(event, null, 2))
const payload = event.payload
if (payload.type && payload.properties && payload.properties.data) {
if (!payload.type.startsWith("server.")) {
console.log(payload)
try {
console.log("replaying")
SyncEvent.replay({
id: payload.properties.id,
type: payload.type,
seq: payload.properties.seq,
aggregateID: payload.properties.aggregateId,
data: payload.properties.data,
id: payload.id,
seq: payload.seq,
aggregateID: payload.aggregateID,
data: payload.data,
})
// console.log("[apply] ok:", event.type)

2
packages/opencode/test/acp/event-subscription.test.ts
View File

@@ -60,6 +60,8 @@ function toolEvent(
const payload: EventMessagePartUpdated = {
type: "message.part.updated",
properties: {
sessionID: sessionId,
time: Date.now(),
part: {
id: `part_${opts.callID}`,
sessionID: sessionId,

3
packages/opencode/test/preload.ts
View File

@@ -76,9 +76,12 @@ delete process.env["OPENCODE_SERVER_USERNAME"]
// Now safe to import from src/
const { Log } = await import("../src/util/log")
const { initProjectors } = await import("../src/server/projectors")
Log.init({
print: false,
dev: true,
level: "DEBUG",
})
initProjectors()

6
packages/opencode/test/session/session.test.ts
View File

@@ -11,7 +11,7 @@ const projectRoot = path.join(__dirname, "../..")
Log.init({ print: false })
describe("session.started event", () => {
test("should emit session.started event when session is created", async () => {
test("should emit session.created event when session is created", async () => {
await Instance.provide({
directory: projectRoot,
fn: async () => {
@@ -20,7 +20,7 @@ describe("session.started event", () => {
const unsub = Bus.subscribe(Session.Event.Created, (event) => {
eventReceived = true
receivedInfo = event.properties.data.info as Session.Info
receivedInfo = event.properties.info as Session.Info
})
const session = await Session.create({})
@@ -95,7 +95,7 @@ describe("step-finish token propagation via Bus event", () => {
let received: MessageV2.Part | undefined
const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
received = event.properties.data.part
received = event.properties.part
})
const tokens = {

18
packages/opencode/test/sync/index.test.ts
View File

@@ -28,18 +28,20 @@ function withInstance(fn: () => void | Promise<void>) {
describe("SyncEvent", () => {
const Created = SyncEvent.define({
type: "item.created",
version: "v1",
version: 1,
aggregate: "id",
schema: z.object({ id: z.string(), name: z.string() }),
})
const Sent = SyncEvent.define({
type: "item.sent",
version: "v1",
version: 1,
aggregate: "item_id",
schema: z.object({ item_id: z.string(), to: z.string() }),
})
SyncEvent.init([SyncEvent.project(Created, () => {}), SyncEvent.project(Sent, () => {})])
SyncEvent.init({
projectors: [SyncEvent.project(Created, () => {}), SyncEvent.project(Sent, () => {})],
})
describe("run", () => {
test(
@@ -48,7 +50,7 @@ describe("SyncEvent", () => {
SyncEvent.run(Created, { id: "msg_1", name: "first" })
const rows = Database.use((db) => db.select().from(EventTable).all())
expect(rows).toHaveLength(1)
expect(rows[0].name).toBe("item.created.v1")
expect(rows[0].name).toBe("item.created.1")
expect(rows[0].aggregate_id).toBe("msg_1")
}),
)
@@ -87,7 +89,7 @@ describe("SyncEvent", () => {
expect(events).toHaveLength(1)
expect(events[0]).toEqual({
type: "item.created.v1",
type: "item.created.1",
properties: {
seq: 0,
aggregateID: "msg_1",
@@ -110,7 +112,7 @@ describe("SyncEvent", () => {
const id = Identifier.descending("message")
SyncEvent.replay({
id: "evt_1",
type: "item.created.v1",
type: "item.created.1",
seq: 0,
aggregateID: id,
data: { id, name: "replayed" },
@@ -127,7 +129,7 @@ describe("SyncEvent", () => {
const id = Identifier.descending("message")
SyncEvent.replay({
id: "evt_1",
type: "item.created.v1",
type: "item.created.1",
seq: 0,
aggregateID: id,
data: { id, name: "first" },
@@ -135,7 +137,7 @@ describe("SyncEvent", () => {
expect(() =>
SyncEvent.replay({
id: "evt_1",
type: "item.created.v1",
type: "item.created.1",
seq: 5,
aggregateID: id,
data: { id, name: "bad" },

0
packages/sdk/js/openapi.json Normal file
View File

18
packages/sdk/js/src/v2/gen/client.gen.ts
View File

@@ -1,18 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import { type ClientOptions, type Config, createClient, createConfig } from "./client/index.js"
import type { ClientOptions as ClientOptions2 } from "./types.gen.js"
/**
* The `createClientConfig()` function will be called on client initialization
* and the returned object will become the client's initial configuration.
*
* You may want to initialize your client this way instead of calling
* `setConfig()`. This is useful for example if you're using Next.js
* to ensure your client always has the correct values.
*/
export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
override?: Config<ClientOptions & T>,
) => Config<Required<ClientOptions> & T>
export const client = createClient(createConfig<ClientOptions2>({ baseUrl: "http://localhost:4096" }))

285
packages/sdk/js/src/v2/gen/client/client.gen.ts
View File

@@ -1,285 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import { createSseClient } from "../core/serverSentEvents.gen.js"
import type { HttpMethod } from "../core/types.gen.js"
import { getValidRequestBody } from "../core/utils.gen.js"
import type { Client, Config, RequestOptions, ResolvedRequestOptions } from "./types.gen.js"
import {
buildUrl,
createConfig,
createInterceptors,
getParseAs,
mergeConfigs,
mergeHeaders,
setAuthParams,
} from "./utils.gen.js"
type ReqInit = Omit<RequestInit, "body" | "headers"> & {
body?: any
headers: ReturnType<typeof mergeHeaders>
}
export const createClient = (config: Config = {}): Client => {
let _config = mergeConfigs(createConfig(), config)
const getConfig = (): Config => ({ ..._config })
const setConfig = (config: Config): Config => {
_config = mergeConfigs(_config, config)
return getConfig()
}
const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>()
const beforeRequest = async (options: RequestOptions) => {
const opts = {
..._config,
...options,
fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
headers: mergeHeaders(_config.headers, options.headers),
serializedBody: undefined,
}
if (opts.security) {
await setAuthParams({
...opts,
security: opts.security,
})
}
if (opts.requestValidator) {
await opts.requestValidator(opts)
}
if (opts.body !== undefined && opts.bodySerializer) {
opts.serializedBody = opts.bodySerializer(opts.body)
}
// remove Content-Type header if body is empty to avoid sending invalid requests
if (opts.body === undefined || opts.serializedBody === "") {
opts.headers.delete("Content-Type")
}
const url = buildUrl(opts)
return { opts, url }
}
const request: Client["request"] = async (options) => {
// @ts-expect-error
const { opts, url } = await beforeRequest(options)
const requestInit: ReqInit = {
redirect: "follow",
...opts,
body: getValidRequestBody(opts),
}
let request = new Request(url, requestInit)
for (const fn of interceptors.request.fns) {
if (fn) {
request = await fn(request, opts)
}
}
// fetch must be assigned here, otherwise it would throw the error:
// TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
const _fetch = opts.fetch!
let response: Response
try {
response = await _fetch(request)
} catch (error) {
// Handle fetch exceptions (AbortError, network errors, etc.)
let finalError = error
for (const fn of interceptors.error.fns) {
if (fn) {
finalError = (await fn(error, undefined as any, request, opts)) as unknown
}
}
finalError = finalError || ({} as unknown)
if (opts.throwOnError) {
throw finalError
}
// Return error response
return opts.responseStyle === "data"
? undefined
: {
error: finalError,
request,
response: undefined as any,
}
}
for (const fn of interceptors.response.fns) {
if (fn) {
response = await fn(response, request, opts)
}
}
const result = {
request,
response,
}
if (response.ok) {
const parseAs =
(opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json"
if (response.status === 204 || response.headers.get("Content-Length") === "0") {
let emptyData: any
switch (parseAs) {
case "arrayBuffer":
case "blob":
case "text":
emptyData = await response[parseAs]()
break
case "formData":
emptyData = new FormData()
break
case "stream":
emptyData = response.body
break
case "json":
default:
emptyData = {}
break
}
return opts.responseStyle === "data"
? emptyData
: {
data: emptyData,
...result,
}
}
let data: any
switch (parseAs) {
case "arrayBuffer":
case "blob":
case "formData":
case "text":
data = await response[parseAs]()
break
case "json": {
// Some servers return 200 with no Content-Length and empty body.
// response.json() would throw; read as text and parse if non-empty.
const text = await response.text()
data = text ? JSON.parse(text) : {}
break
}
case "stream":
return opts.responseStyle === "data"
? response.body
: {
data: response.body,
...result,
}
}
if (parseAs === "json") {
if (opts.responseValidator) {
await opts.responseValidator(data)
}
if (opts.responseTransformer) {
data = await opts.responseTransformer(data)
}
}
return opts.responseStyle === "data"
? data
: {
data,
...result,
}
}
const textError = await response.text()
let jsonError: unknown
try {
jsonError = JSON.parse(textError)
} catch {
// noop
}
const error = jsonError ?? textError
let finalError = error
for (const fn of interceptors.error.fns) {
if (fn) {
finalError = (await fn(error, response, request, opts)) as string
}
}
finalError = finalError || ({} as string)
if (opts.throwOnError) {
throw finalError
}
// TODO: we probably want to return error and improve types
return opts.responseStyle === "data"
? undefined
: {
error: finalError,
...result,
}
}
const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) => request({ ...options, method })
const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
const { opts, url } = await beforeRequest(options)
return createSseClient({
...opts,
body: opts.body as BodyInit | null | undefined,
headers: opts.headers as unknown as Record<string, string>,
method,
onRequest: async (url, init) => {
let request = new Request(url, init)
for (const fn of interceptors.request.fns) {
if (fn) {
request = await fn(request, opts)
}
}
return request
},
serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
url,
})
}
return {
buildUrl,
connect: makeMethodFn("CONNECT"),
delete: makeMethodFn("DELETE"),
get: makeMethodFn("GET"),
getConfig,
head: makeMethodFn("HEAD"),
interceptors,
options: makeMethodFn("OPTIONS"),
patch: makeMethodFn("PATCH"),
post: makeMethodFn("POST"),
put: makeMethodFn("PUT"),
request,
setConfig,
sse: {
connect: makeSseFn("CONNECT"),
delete: makeSseFn("DELETE"),
get: makeSseFn("GET"),
head: makeSseFn("HEAD"),
options: makeSseFn("OPTIONS"),
patch: makeSseFn("PATCH"),
post: makeSseFn("POST"),
put: makeSseFn("PUT"),
trace: makeSseFn("TRACE"),
},
trace: makeMethodFn("TRACE"),
} as Client
}

25
packages/sdk/js/src/v2/gen/client/index.ts
View File

@@ -1,25 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
export type { Auth } from "../core/auth.gen.js"
export type { QuerySerializerOptions } from "../core/bodySerializer.gen.js"
export {
formDataBodySerializer,
jsonBodySerializer,
urlSearchParamsBodySerializer,
} from "../core/bodySerializer.gen.js"
export { buildClientParams } from "../core/params.gen.js"
export { serializeQueryKeyValue } from "../core/queryKeySerializer.gen.js"
export { createClient } from "./client.gen.js"
export type {
Client,
ClientOptions,
Config,
CreateClientConfig,
Options,
RequestOptions,
RequestResult,
ResolvedRequestOptions,
ResponseStyle,
TDataShape,
} from "./types.gen.js"
export { createConfig, mergeHeaders } from "./utils.gen.js"

202
packages/sdk/js/src/v2/gen/client/types.gen.ts
View File

@@ -1,202 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { Auth } from "../core/auth.gen.js"
import type { ServerSentEventsOptions, ServerSentEventsResult } from "../core/serverSentEvents.gen.js"
import type { Client as CoreClient, Config as CoreConfig } from "../core/types.gen.js"
import type { Middleware } from "./utils.gen.js"
export type ResponseStyle = "data" | "fields"
export interface Config<T extends ClientOptions = ClientOptions>
extends Omit<RequestInit, "body" | "headers" | "method">,
CoreConfig {
/**
* Base URL for all requests made by this client.
*/
baseUrl?: T["baseUrl"]
/**
* Fetch API implementation. You can use this option to provide a custom
* fetch instance.
*
* @default globalThis.fetch
*/
fetch?: typeof fetch
/**
* Please don't use the Fetch client for Next.js applications. The `next`
* options won't have any effect.
*
* Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
*/
next?: never
/**
* Return the response data parsed in a specified format. By default, `auto`
* will infer the appropriate method from the `Content-Type` response header.
* You can override this behavior with any of the {@link Body} methods.
* Select `stream` if you don't want to parse response data at all.
*
* @default 'auto'
*/
parseAs?: "arrayBuffer" | "auto" | "blob" | "formData" | "json" | "stream" | "text"
/**
* Should we return only data or multiple fields (data, error, response, etc.)?
*
* @default 'fields'
*/
responseStyle?: ResponseStyle
/**
* Throw an error instead of returning it in the response?
*
* @default false
*/
throwOnError?: T["throwOnError"]
}
export interface RequestOptions<
TData = unknown,
TResponseStyle extends ResponseStyle = "fields",
ThrowOnError extends boolean = boolean,
Url extends string = string,
> extends Config<{
responseStyle: TResponseStyle
throwOnError: ThrowOnError
}>,
Pick<
ServerSentEventsOptions<TData>,
"onSseError" | "onSseEvent" | "sseDefaultRetryDelay" | "sseMaxRetryAttempts" | "sseMaxRetryDelay"
> {
/**
* Any body that you want to add to your request.
*
* {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
*/
body?: unknown
path?: Record<string, unknown>
query?: Record<string, unknown>
/**
* Security mechanism(s) to use for the request.
*/
security?: ReadonlyArray<Auth>
url: Url
}
export interface ResolvedRequestOptions<
TResponseStyle extends ResponseStyle = "fields",
ThrowOnError extends boolean = boolean,
Url extends string = string,
> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
serializedBody?: string
}
export type RequestResult<
TData = unknown,
TError = unknown,
ThrowOnError extends boolean = boolean,
TResponseStyle extends ResponseStyle = "fields",
> = ThrowOnError extends true
? Promise<
TResponseStyle extends "data"
? TData extends Record<string, unknown>
? TData[keyof TData]
: TData
: {
data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
request: Request
response: Response
}
>
: Promise<
TResponseStyle extends "data"
? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined
: (
| {
data: TData extends Record<string, unknown> ? TData[keyof TData] : TData
error: undefined
}
| {
data: undefined
error: TError extends Record<string, unknown> ? TError[keyof TError] : TError
}
) & {
request: Request
response: Response
}
>
export interface ClientOptions {
baseUrl?: string
responseStyle?: ResponseStyle
throwOnError?: boolean
}
type MethodFn = <
TData = unknown,
TError = unknown,
ThrowOnError extends boolean = false,
TResponseStyle extends ResponseStyle = "fields",
>(
options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
type SseFn = <
TData = unknown,
TError = unknown,
ThrowOnError extends boolean = false,
TResponseStyle extends ResponseStyle = "fields",
>(
options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method">,
) => Promise<ServerSentEventsResult<TData, TError>>
type RequestFn = <
TData = unknown,
TError = unknown,
ThrowOnError extends boolean = false,
TResponseStyle extends ResponseStyle = "fields",
>(
options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, "method"> &
Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, "method">,
) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>
type BuildUrlFn = <
TData extends {
body?: unknown
path?: Record<string, unknown>
query?: Record<string, unknown>
url: string
},
>(
options: TData & Options<TData>,
) => string
export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>
}
/**
* The `createClientConfig()` function will be called on client initialization
* and the returned object will become the client's initial configuration.
*
* You may want to initialize your client this way instead of calling
* `setConfig()`. This is useful for example if you're using Next.js
* to ensure your client always has the correct values.
*/
export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
override?: Config<ClientOptions & T>,
) => Config<Required<ClientOptions> & T>
export interface TDataShape {
body?: unknown
headers?: unknown
path?: unknown
query?: unknown
url: string
}
type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>
export type Options<
TData extends TDataShape = TDataShape,
ThrowOnError extends boolean = boolean,
TResponse = unknown,
TResponseStyle extends ResponseStyle = "fields",
> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, "body" | "path" | "query" | "url"> &
([TData] extends [never] ? unknown : Omit<TData, "url">)

289
packages/sdk/js/src/v2/gen/client/utils.gen.ts
View File

@@ -1,289 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import { getAuthToken } from "../core/auth.gen.js"
import type { QuerySerializerOptions } from "../core/bodySerializer.gen.js"
import { jsonBodySerializer } from "../core/bodySerializer.gen.js"
import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam } from "../core/pathSerializer.gen.js"
import { getUrl } from "../core/utils.gen.js"
import type { Client, ClientOptions, Config, RequestOptions } from "./types.gen.js"
export const createQuerySerializer = <T = unknown>({ parameters = {}, ...args }: QuerySerializerOptions = {}) => {
const querySerializer = (queryParams: T) => {
const search: string[] = []
if (queryParams && typeof queryParams === "object") {
for (const name in queryParams) {
const value = queryParams[name]
if (value === undefined || value === null) {
continue
}
const options = parameters[name] || args
if (Array.isArray(value)) {
const serializedArray = serializeArrayParam({
allowReserved: options.allowReserved,
explode: true,
name,
style: "form",
value,
...options.array,
})
if (serializedArray) search.push(serializedArray)
} else if (typeof value === "object") {
const serializedObject = serializeObjectParam({
allowReserved: options.allowReserved,
explode: true,
name,
style: "deepObject",
value: value as Record<string, unknown>,
...options.object,
})
if (serializedObject) search.push(serializedObject)
} else {
const serializedPrimitive = serializePrimitiveParam({
allowReserved: options.allowReserved,
name,
value: value as string,
})
if (serializedPrimitive) search.push(serializedPrimitive)
}
}
}
return search.join("&")
}
return querySerializer
}
/**
* Infers parseAs value from provided Content-Type header.
*/
export const getParseAs = (contentType: string | null): Exclude<Config["parseAs"], "auto"> => {
if (!contentType) {
// If no Content-Type header is provided, the best we can do is return the raw response body,
// which is effectively the same as the 'stream' option.
return "stream"
}
const cleanContent = contentType.split(";")[0]?.trim()
if (!cleanContent) {
return
}
if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
return "json"
}
if (cleanContent === "multipart/form-data") {
return "formData"
}
if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
return "blob"
}
if (cleanContent.startsWith("text/")) {
return "text"
}
return
}
const checkForExistence = (
options: Pick<RequestOptions, "auth" | "query"> & {
headers: Headers
},
name?: string,
): boolean => {
if (!name) {
return false
}
if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
return true
}
return false
}
export const setAuthParams = async ({
security,
...options
}: Pick<Required<RequestOptions>, "security"> &
Pick<RequestOptions, "auth" | "query"> & {
headers: Headers
}) => {
for (const auth of security) {
if (checkForExistence(options, auth.name)) {
continue
}
const token = await getAuthToken(auth, options.auth)
if (!token) {
continue
}
const name = auth.name ?? "Authorization"
switch (auth.in) {
case "query":
if (!options.query) {
options.query = {}
}
options.query[name] = token
break
case "cookie":
options.headers.append("Cookie", `${name}=${token}`)
break
case "header":
default:
options.headers.set(name, token)
break
}
}
}
export const buildUrl: Client["buildUrl"] = (options) =>
getUrl({
baseUrl: options.baseUrl as string,
path: options.path,
query: options.query,
querySerializer:
typeof options.querySerializer === "function"
? options.querySerializer
: createQuerySerializer(options.querySerializer),
url: options.url,
})
export const mergeConfigs = (a: Config, b: Config): Config => {
const config = { ...a, ...b }
if (config.baseUrl?.endsWith("/")) {
config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1)
}
config.headers = mergeHeaders(a.headers, b.headers)
return config
}
const headersEntries = (headers: Headers): Array<[string, string]> => {
const entries: Array<[string, string]> = []
headers.forEach((value, key) => {
entries.push([key, value])
})
return entries
}
export const mergeHeaders = (...headers: Array<Required<Config>["headers"] | undefined>): Headers => {
const mergedHeaders = new Headers()
for (const header of headers) {
if (!header) {
continue
}
const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header)
for (const [key, value] of iterator) {
if (value === null) {
mergedHeaders.delete(key)
} else if (Array.isArray(value)) {
for (const v of value) {
mergedHeaders.append(key, v as string)
}
} else if (value !== undefined) {
// assume object headers are meant to be JSON stringified, i.e. their
// content value in OpenAPI specification is 'application/json'
mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : (value as string))
}
}
}
return mergedHeaders
}
type ErrInterceptor<Err, Res, Req, Options> = (
error: Err,
response: Res,
request: Req,
options: Options,
) => Err | Promise<Err>
type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>
type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>
class Interceptors<Interceptor> {
fns: Array<Interceptor | null> = []
clear(): void {
this.fns = []
}
eject(id: number | Interceptor): void {
const index = this.getInterceptorIndex(id)
if (this.fns[index]) {
this.fns[index] = null
}
}
exists(id: number | Interceptor): boolean {
const index = this.getInterceptorIndex(id)
return Boolean(this.fns[index])
}
getInterceptorIndex(id: number | Interceptor): number {
if (typeof id === "number") {
return this.fns[id] ? id : -1
}
return this.fns.indexOf(id)
}
update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false {
const index = this.getInterceptorIndex(id)
if (this.fns[index]) {
this.fns[index] = fn
return id
}
return false
}
use(fn: Interceptor): number {
this.fns.push(fn)
return this.fns.length - 1
}
}
export interface Middleware<Req, Res, Err, Options> {
error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>
request: Interceptors<ReqInterceptor<Req, Options>>
response: Interceptors<ResInterceptor<Res, Req, Options>>
}
export const createInterceptors = <Req, Res, Err, Options>(): Middleware<Req, Res, Err, Options> => ({
error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
request: new Interceptors<ReqInterceptor<Req, Options>>(),
response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
})
const defaultQuerySerializer = createQuerySerializer({
allowReserved: false,
array: {
explode: true,
style: "form",
},
object: {
explode: true,
style: "deepObject",
},
})
const defaultHeaders = {
"Content-Type": "application/json",
}
export const createConfig = <T extends ClientOptions = ClientOptions>(
override: Config<Omit<ClientOptions, keyof T> & T> = {},
): Config<Omit<ClientOptions, keyof T> & T> => ({
...jsonBodySerializer,
headers: defaultHeaders,
parseAs: "auto",
querySerializer: defaultQuerySerializer,
...override,
})

41
packages/sdk/js/src/v2/gen/core/auth.gen.ts
View File

@@ -1,41 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
export type AuthToken = string | undefined
export interface Auth {
/**
* Which part of the request do we use to send the auth?
*
* @default 'header'
*/
in?: "header" | "query" | "cookie"
/**
* Header or query parameter name.
*
* @default 'Authorization'
*/
name?: string
scheme?: "basic" | "bearer"
type: "apiKey" | "http"
}
export const getAuthToken = async (
auth: Auth,
callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
): Promise<string | undefined> => {
const token = typeof callback === "function" ? await callback(auth) : callback
if (!token) {
return
}
if (auth.scheme === "bearer") {
return `Bearer ${token}`
}
if (auth.scheme === "basic") {
return `Basic ${btoa(token)}`
}
return token
}

82
packages/sdk/js/src/v2/gen/core/bodySerializer.gen.ts
View File

@@ -1,82 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { ArrayStyle, ObjectStyle, SerializerOptions } from "./pathSerializer.gen.js"
export type QuerySerializer = (query: Record<string, unknown>) => string
export type BodySerializer = (body: any) => any
type QuerySerializerOptionsObject = {
allowReserved?: boolean
array?: Partial<SerializerOptions<ArrayStyle>>
object?: Partial<SerializerOptions<ObjectStyle>>
}
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
/**
* Per-parameter serialization overrides. When provided, these settings
* override the global array/object settings for specific parameter names.
*/
parameters?: Record<string, QuerySerializerOptionsObject>
}
const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
if (typeof value === "string" || value instanceof Blob) {
data.append(key, value)
} else if (value instanceof Date) {
data.append(key, value.toISOString())
} else {
data.append(key, JSON.stringify(value))
}
}
const serializeUrlSearchParamsPair = (data: URLSearchParams, key: string, value: unknown): void => {
if (typeof value === "string") {
data.append(key, value)
} else {
data.append(key, JSON.stringify(value))
}
}
export const formDataBodySerializer = {
bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): FormData => {
const data = new FormData()
Object.entries(body).forEach(([key, value]) => {
if (value === undefined || value === null) {
return
}
if (Array.isArray(value)) {
value.forEach((v) => serializeFormDataPair(data, key, v))
} else {
serializeFormDataPair(data, key, value)
}
})
return data
},
}
export const jsonBodySerializer = {
bodySerializer: <T>(body: T): string =>
JSON.stringify(body, (_key, value) => (typeof value === "bigint" ? value.toString() : value)),
}
export const urlSearchParamsBodySerializer = {
bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T): string => {
const data = new URLSearchParams()
Object.entries(body).forEach(([key, value]) => {
if (value === undefined || value === null) {
return
}
if (Array.isArray(value)) {
value.forEach((v) => serializeUrlSearchParamsPair(data, key, v))
} else {
serializeUrlSearchParamsPair(data, key, value)
}
})
return data.toString()
},
}

169
packages/sdk/js/src/v2/gen/core/params.gen.ts
View File

@@ -1,169 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
type Slot = "body" | "headers" | "path" | "query"
export type Field =
| {
in: Exclude<Slot, "body">
/**
* Field name. This is the name we want the user to see and use.
*/
key: string
/**
* Field mapped name. This is the name we want to use in the request.
* If omitted, we use the same value as `key`.
*/
map?: string
}
| {
in: Extract<Slot, "body">
/**
* Key isn't required for bodies.
*/
key?: string
map?: string
}
| {
/**
* Field name. This is the name we want the user to see and use.
*/
key: string
/**
* Field mapped name. This is the name we want to use in the request.
* If `in` is omitted, `map` aliases `key` to the transport layer.
*/
map: Slot
}
export interface Fields {
allowExtra?: Partial<Record<Slot, boolean>>
args?: ReadonlyArray<Field>
}
export type FieldsConfig = ReadonlyArray<Field | Fields>
const extraPrefixesMap: Record<string, Slot> = {
$body_: "body",
$headers_: "headers",
$path_: "path",
$query_: "query",
}
const extraPrefixes = Object.entries(extraPrefixesMap)
type KeyMap = Map<
string,
| {
in: Slot
map?: string
}
| {
in?: never
map: Slot
}
>
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
if (!map) {
map = new Map()
}
for (const config of fields) {
if ("in" in config) {
if (config.key) {
map.set(config.key, {
in: config.in,
map: config.map,
})
}
} else if ("key" in config) {
map.set(config.key, {
map: config.map,
})
} else if (config.args) {
buildKeyMap(config.args, map)
}
}
return map
}
interface Params {
body: unknown
headers: Record<string, unknown>
path: Record<string, unknown>
query: Record<string, unknown>
}
const stripEmptySlots = (params: Params) => {
for (const [slot, value] of Object.entries(params)) {
if (value && typeof value === "object" && !Object.keys(value).length) {
delete params[slot as Slot]
}
}
}
export const buildClientParams = (args: ReadonlyArray<unknown>, fields: FieldsConfig) => {
const params: Params = {
body: {},
headers: {},
path: {},
query: {},
}
const map = buildKeyMap(fields)
let config: FieldsConfig[number] | undefined
for (const [index, arg] of args.entries()) {
if (fields[index]) {
config = fields[index]
}
if (!config) {
continue
}
if ("in" in config) {
if (config.key) {
const field = map.get(config.key)!
const name = field.map || config.key
if (field.in) {
;(params[field.in] as Record<string, unknown>)[name] = arg
}
} else {
params.body = arg
}
} else {
for (const [key, value] of Object.entries(arg ?? {})) {
const field = map.get(key)
if (field) {
if (field.in) {
const name = field.map || key
;(params[field.in] as Record<string, unknown>)[name] = value
} else {
params[field.map] = value
}
} else {
const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix))
if (extra) {
const [prefix, slot] = extra
;(params[slot] as Record<string, unknown>)[key.slice(prefix.length)] = value
} else if ("allowExtra" in config && config.allowExtra) {
for (const [slot, allowed] of Object.entries(config.allowExtra)) {
if (allowed) {
;(params[slot as Slot] as Record<string, unknown>)[key] = value
break
}
}
}
}
}
}
}
stripEmptySlots(params)
return params
}

167
packages/sdk/js/src/v2/gen/core/pathSerializer.gen.ts
View File

@@ -1,167 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
interface SerializeOptions<T> extends SerializePrimitiveOptions, SerializerOptions<T> {}
interface SerializePrimitiveOptions {
allowReserved?: boolean
name: string
}
export interface SerializerOptions<T> {
/**
* @default true
*/
explode: boolean
style: T
}
export type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited"
export type ArraySeparatorStyle = ArrayStyle | MatrixStyle
type MatrixStyle = "label" | "matrix" | "simple"
export type ObjectStyle = "form" | "deepObject"
type ObjectSeparatorStyle = ObjectStyle | MatrixStyle
interface SerializePrimitiveParam extends SerializePrimitiveOptions {
value: string
}
export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
switch (style) {
case "label":
return "."
case "matrix":
return ";"
case "simple":
return ","
default:
return "&"
}
}
export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
switch (style) {
case "form":
return ","
case "pipeDelimited":
return "|"
case "spaceDelimited":
return "%20"
default:
return ","
}
}
export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
switch (style) {
case "label":
return "."
case "matrix":
return ";"
case "simple":
return ","
default:
return "&"
}
}
export const serializeArrayParam = ({
allowReserved,
explode,
name,
style,
value,
}: SerializeOptions<ArraySeparatorStyle> & {
value: unknown[]
}) => {
if (!explode) {
const joinedValues = (allowReserved ? value : value.map((v) => encodeURIComponent(v as string))).join(
separatorArrayNoExplode(style),
)
switch (style) {
case "label":
return `.${joinedValues}`
case "matrix":
return `;${name}=${joinedValues}`
case "simple":
return joinedValues
default:
return `${name}=${joinedValues}`
}
}
const separator = separatorArrayExplode(style)
const joinedValues = value
.map((v) => {
if (style === "label" || style === "simple") {
return allowReserved ? v : encodeURIComponent(v as string)
}
return serializePrimitiveParam({
allowReserved,
name,
value: v as string,
})
})
.join(separator)
return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues
}
export const serializePrimitiveParam = ({ allowReserved, name, value }: SerializePrimitiveParam) => {
if (value === undefined || value === null) {
return ""
}
if (typeof value === "object") {
throw new Error(
"Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.",
)
}
return `${name}=${allowReserved ? value : encodeURIComponent(value)}`
}
export const serializeObjectParam = ({
allowReserved,
explode,
name,
style,
value,
valueOnly,
}: SerializeOptions<ObjectSeparatorStyle> & {
value: Record<string, unknown> | Date
valueOnly?: boolean
}) => {
if (value instanceof Date) {
return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`
}
if (style !== "deepObject" && !explode) {
let values: string[] = []
Object.entries(value).forEach(([key, v]) => {
values = [...values, key, allowReserved ? (v as string) : encodeURIComponent(v as string)]
})
const joinedValues = values.join(",")
switch (style) {
case "form":
return `${name}=${joinedValues}`
case "label":
return `.${joinedValues}`
case "matrix":
return `;${name}=${joinedValues}`
default:
return joinedValues
}
}
const separator = separatorObjectExplode(style)
const joinedValues = Object.entries(value)
.map(([key, v]) =>
serializePrimitiveParam({
allowReserved,
name: style === "deepObject" ? `${name}[${key}]` : key,
value: v as string,
}),
)
.join(separator)
return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues
}

111
packages/sdk/js/src/v2/gen/core/queryKeySerializer.gen.ts
View File

@@ -1,111 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
/**
* JSON-friendly union that mirrors what Pinia Colada can hash.
*/
export type JsonValue = null | string | number | boolean | JsonValue[] | { [key: string]: JsonValue }
/**
* Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
*/
export const queryKeyJsonReplacer = (_key: string, value: unknown) => {
if (value === undefined || typeof value === "function" || typeof value === "symbol") {
return undefined
}
if (typeof value === "bigint") {
return value.toString()
}
if (value instanceof Date) {
return value.toISOString()
}
return value
}
/**
* Safely stringifies a value and parses it back into a JsonValue.
*/
export const stringifyToJsonValue = (input: unknown): JsonValue | undefined => {
try {
const json = JSON.stringify(input, queryKeyJsonReplacer)
if (json === undefined) {
return undefined
}
return JSON.parse(json) as JsonValue
} catch {
return undefined
}
}
/**
* Detects plain objects (including objects with a null prototype).
*/
const isPlainObject = (value: unknown): value is Record<string, unknown> => {
if (value === null || typeof value !== "object") {
return false
}
const prototype = Object.getPrototypeOf(value as object)
return prototype === Object.prototype || prototype === null
}
/**
* Turns URLSearchParams into a sorted JSON object for deterministic keys.
*/
const serializeSearchParams = (params: URLSearchParams): JsonValue => {
const entries = Array.from(params.entries()).sort(([a], [b]) => a.localeCompare(b))
const result: Record<string, JsonValue> = {}
for (const [key, value] of entries) {
const existing = result[key]
if (existing === undefined) {
result[key] = value
continue
}
if (Array.isArray(existing)) {
;(existing as string[]).push(value)
} else {
result[key] = [existing, value]
}
}
return result
}
/**
* Normalizes any accepted value into a JSON-friendly shape for query keys.
*/
export const serializeQueryKeyValue = (value: unknown): JsonValue | undefined => {
if (value === null) {
return null
}
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
return value
}
if (value === undefined || typeof value === "function" || typeof value === "symbol") {
return undefined
}
if (typeof value === "bigint") {
return value.toString()
}
if (value instanceof Date) {
return value.toISOString()
}
if (Array.isArray(value)) {
return stringifyToJsonValue(value)
}
if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) {
return serializeSearchParams(value)
}
if (isPlainObject(value)) {
return stringifyToJsonValue(value)
}
return undefined
}

239
packages/sdk/js/src/v2/gen/core/serverSentEvents.gen.ts
View File

@@ -1,239 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { Config } from "./types.gen.js"
export type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, "method"> &
Pick<Config, "method" | "responseTransformer" | "responseValidator"> & {
/**
* Fetch API implementation. You can use this option to provide a custom
* fetch instance.
*
* @default globalThis.fetch
*/
fetch?: typeof fetch
/**
* Implementing clients can call request interceptors inside this hook.
*/
onRequest?: (url: string, init: RequestInit) => Promise<Request>
/**
* Callback invoked when a network or parsing error occurs during streaming.
*
* This option applies only if the endpoint returns a stream of events.
*
* @param error The error that occurred.
*/
onSseError?: (error: unknown) => void
/**
* Callback invoked when an event is streamed from the server.
*
* This option applies only if the endpoint returns a stream of events.
*
* @param event Event streamed from the server.
* @returns Nothing (void).
*/
onSseEvent?: (event: StreamEvent<TData>) => void
serializedBody?: RequestInit["body"]
/**
* Default retry delay in milliseconds.
*
* This option applies only if the endpoint returns a stream of events.
*
* @default 3000
*/
sseDefaultRetryDelay?: number
/**
* Maximum number of retry attempts before giving up.
*/
sseMaxRetryAttempts?: number
/**
* Maximum retry delay in milliseconds.
*
* Applies only when exponential backoff is used.
*
* This option applies only if the endpoint returns a stream of events.
*
* @default 30000
*/
sseMaxRetryDelay?: number
/**
* Optional sleep function for retry backoff.
*
* Defaults to using `setTimeout`.
*/
sseSleepFn?: (ms: number) => Promise<void>
url: string
}
export interface StreamEvent<TData = unknown> {
data: TData
event?: string
id?: string
retry?: number
}
export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>
}
export const createSseClient = <TData = unknown>({
onRequest,
onSseError,
onSseEvent,
responseTransformer,
responseValidator,
sseDefaultRetryDelay,
sseMaxRetryAttempts,
sseMaxRetryDelay,
sseSleepFn,
url,
...options
}: ServerSentEventsOptions): ServerSentEventsResult<TData> => {
let lastEventId: string | undefined
const sleep = sseSleepFn ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)))
const createStream = async function* () {
let retryDelay: number = sseDefaultRetryDelay ?? 3000
let attempt = 0
const signal = options.signal ?? new AbortController().signal
while (true) {
if (signal.aborted) break
attempt++
const headers =
options.headers instanceof Headers
? options.headers
: new Headers(options.headers as Record<string, string> | undefined)
if (lastEventId !== undefined) {
headers.set("Last-Event-ID", lastEventId)
}
try {
const requestInit: RequestInit = {
redirect: "follow",
...options,
body: options.serializedBody,
headers,
signal,
}
let request = new Request(url, requestInit)
if (onRequest) {
request = await onRequest(url, requestInit)
}
// fetch must be assigned here, otherwise it would throw the error:
// TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
const _fetch = options.fetch ?? globalThis.fetch
const response = await _fetch(request)
if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`)
if (!response.body) throw new Error("No body in SSE response")
const reader = response.body.pipeThrough(new TextDecoderStream()).getReader()
let buffer = ""
const abortHandler = () => {
try {
reader.cancel()
} catch {
// noop
}
}
signal.addEventListener("abort", abortHandler)
try {
while (true) {
const { done, value } = await reader.read()
if (done) break
buffer += value
// Normalize line endings: CRLF -> LF, then CR -> LF
buffer = buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
const chunks = buffer.split("\n\n")
buffer = chunks.pop() ?? ""
for (const chunk of chunks) {
const lines = chunk.split("\n")
const dataLines: Array<string> = []
let eventName: string | undefined
for (const line of lines) {
if (line.startsWith("data:")) {
dataLines.push(line.replace(/^data:\s*/, ""))
} else if (line.startsWith("event:")) {
eventName = line.replace(/^event:\s*/, "")
} else if (line.startsWith("id:")) {
lastEventId = line.replace(/^id:\s*/, "")
} else if (line.startsWith("retry:")) {
const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10)
if (!Number.isNaN(parsed)) {
retryDelay = parsed
}
}
}
let data: unknown
let parsedJson = false
if (dataLines.length) {
const rawData = dataLines.join("\n")
try {
data = JSON.parse(rawData)
parsedJson = true
} catch {
data = rawData
}
}
if (parsedJson) {
if (responseValidator) {
await responseValidator(data)
}
if (responseTransformer) {
data = await responseTransformer(data)
}
}
onSseEvent?.({
data,
event: eventName,
id: lastEventId,
retry: retryDelay,
})
if (dataLines.length) {
yield data as any
}
}
}
} finally {
signal.removeEventListener("abort", abortHandler)
reader.releaseLock()
}
break // exit loop on normal completion
} catch (error) {
// connection failed or aborted; retry after delay
onSseError?.(error)
if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
break // stop after firing error
}
// exponential backoff: double retry each attempt, cap at 30s
const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000)
await sleep(backoff)
}
}
}
const stream = createStream()
return { stream }
}

86
packages/sdk/js/src/v2/gen/core/types.gen.ts
View File

@@ -1,86 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { Auth, AuthToken } from "./auth.gen.js"
import type { BodySerializer, QuerySerializer, QuerySerializerOptions } from "./bodySerializer.gen.js"
export type HttpMethod = "connect" | "delete" | "get" | "head" | "options" | "patch" | "post" | "put" | "trace"
export type Client<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
/**
* Returns the final request URL.
*/
buildUrl: BuildUrlFn
getConfig: () => Config
request: RequestFn
setConfig: (config: Config) => Config
} & {
[K in HttpMethod]: MethodFn
} & ([SseFn] extends [never] ? { sse?: never } : { sse: { [K in HttpMethod]: SseFn } })
export interface Config {
/**
* Auth token or a function returning auth token. The resolved value will be
* added to the request payload as defined by its `security` array.
*/
auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken
/**
* A function for serializing request body parameter. By default,
* {@link JSON.stringify()} will be used.
*/
bodySerializer?: BodySerializer | null
/**
* An object containing any HTTP headers that you want to pre-populate your
* `Headers` object with.
*
* {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
*/
headers?:
| RequestInit["headers"]
| Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>
/**
* The request method.
*
* {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
*/
method?: Uppercase<HttpMethod>
/**
* A function for serializing request query parameters. By default, arrays
* will be exploded in form style, objects will be exploded in deepObject
* style, and reserved characters are percent-encoded.
*
* This method will have no effect if the native `paramsSerializer()` Axios
* API function is used.
*
* {@link https://swagger.io/docs/specification/serialization/#query View examples}
*/
querySerializer?: QuerySerializer | QuerySerializerOptions
/**
* A function validating request data. This is useful if you want to ensure
* the request conforms to the desired shape, so it can be safely sent to
* the server.
*/
requestValidator?: (data: unknown) => Promise<unknown>
/**
* A function transforming response data before it's returned. This is useful
* for post-processing data, e.g. converting ISO strings into Date objects.
*/
responseTransformer?: (data: unknown) => Promise<unknown>
/**
* A function validating response data. This is useful if you want to ensure
* the response conforms to the desired shape, so it can be safely passed to
* the transformers and returned to the user.
*/
responseValidator?: (data: unknown) => Promise<unknown>
}
type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
? true
: [T] extends [never | undefined]
? [undefined] extends [T]
? false
: true
: false
export type OmitNever<T extends Record<string, unknown>> = {
[K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K]
}

137
packages/sdk/js/src/v2/gen/core/utils.gen.ts
View File

@@ -1,137 +0,0 @@
// This file is auto-generated by @hey-api/openapi-ts
import type { BodySerializer, QuerySerializer } from "./bodySerializer.gen.js"
import {
type ArraySeparatorStyle,
serializeArrayParam,
serializeObjectParam,
serializePrimitiveParam,
} from "./pathSerializer.gen.js"
export interface PathSerializer {
path: Record<string, unknown>
url: string
}
export const PATH_PARAM_RE = /\{[^{}]+\}/g
export const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
let url = _url
const matches = _url.match(PATH_PARAM_RE)
if (matches) {
for (const match of matches) {
let explode = false
let name = match.substring(1, match.length - 1)
let style: ArraySeparatorStyle = "simple"
if (name.endsWith("*")) {
explode = true
name = name.substring(0, name.length - 1)
}
if (name.startsWith(".")) {
name = name.substring(1)
style = "label"
} else if (name.startsWith(";")) {
name = name.substring(1)
style = "matrix"
}
const value = path[name]
if (value === undefined || value === null) {
continue
}
if (Array.isArray(value)) {
url = url.replace(match, serializeArrayParam({ explode, name, style, value }))
continue
}
if (typeof value === "object") {
url = url.replace(
match,
serializeObjectParam({
explode,
name,
style,
value: value as Record<string, unknown>,
valueOnly: true,
}),
)
continue
}
if (style === "matrix") {
url = url.replace(
match,
`;${serializePrimitiveParam({
name,
value: value as string,
})}`,
)
continue
}
const replaceValue = encodeURIComponent(style === "label" ? `.${value as string}` : (value as string))
url = url.replace(match, replaceValue)
}
}
return url
}
export const getUrl = ({
baseUrl,
path,
query,
querySerializer,
url: _url,
}: {
baseUrl?: string
path?: Record<string, unknown>
query?: Record<string, unknown>
querySerializer: QuerySerializer
url: string
}) => {
const pathUrl = _url.startsWith("/") ? _url : `/${_url}`
let url = (baseUrl ?? "") + pathUrl
if (path) {
url = defaultPathSerializer({ path, url })
}
let search = query ? querySerializer(query) : ""
if (search.startsWith("?")) {
search = search.substring(1)
}
if (search) {
url += `?${search}`
}
return url
}
export function getValidRequestBody(options: {
body?: unknown
bodySerializer?: BodySerializer | null
serializedBody?: unknown
}) {
const hasBody = options.body !== undefined
const isSerializedBody = hasBody && options.bodySerializer
if (isSerializedBody) {
if ("serializedBody" in options) {
const hasSerializedBody = options.serializedBody !== undefined && options.serializedBody !== ""
return hasSerializedBody ? options.serializedBody : null
}
// not all clients implement a serializedBody property (i.e. client-axios)
return options.body !== "" ? options.body : null
}
// plain/text body
if (hasBody) {
return options.body
}
// no body was provided
return undefined
}

3201
packages/sdk/openapi.json
View File

File diff suppressed because it is too large Load Diff

2
script/generate.ts
View File

@@ -6,4 +6,4 @@ await $`bun ./packages/sdk/js/script/build.ts`
await $`bun dev generate > ../sdk/openapi.json`.cwd("packages/opencode")
await $`./script/format.ts`
// await $`./script/format.ts`