@polytric/openws-sdkgen 0.0.5 → 0.0.6

package/dist/templates/typescript/src/core/network.ts.ejs

@@ -0,0 +1,517 @@
+export const networkName = <%- JSON.stringify(ctx.networkName) %>
+export const networkDescription = <%- JSON.stringify(ctx.description ?? '') %>
+export const networkVersion = <%- JSON.stringify(ctx.version ?? '1.0.0') %>
+
+export const endpoints = <%- JSON.stringify(
+    Object.fromEntries(ctx.allRoles.map(role => [role.roleName, role.endpoints])),
+    null,
+    4
+) %>
+
+<% if (ctx.isTypeScript) { -%>
+export interface OpenWsEnvelope<Payload = unknown> {
+    fromRole: string
+    messageName: string
+    payload: Payload
+}
+
+export interface OpenWsEndpoint {
+    scheme: string
+    host?: string
+    port?: number
+    path?: string
+}
+
+export type Unsubscribe = () => void
+export type TransportEvent = 'message' | 'error'
+export type TransportHandler = (data: unknown) => void | Promise<void>
+
+export interface Transport {
+    send(data: string): void | Promise<void>
+    on?(event: TransportEvent, handler: TransportHandler): unknown
+    close?(): void
+    connect?(roleName: string, endpoint?: OpenWsEndpoint): void | Promise<void>
+    disconnect?(roleName: string): void | Promise<void>
+}
+
+export interface BindTransportOptions {
+    closeOnError?: boolean
+}
+
+export interface RawMessageHandler {
+    handleRawMessage(data: string): void | Promise<void>
+    messageError?(error: unknown): void | Promise<void>
+    socketError?(error: unknown): void | Promise<void>
+}
+
+export function encodeEnvelope(envelope: OpenWsEnvelope): string {
+    return JSON.stringify(envelope)
+}
+
+export function decodeEnvelope(data: string): OpenWsEnvelope {
+    return JSON.parse(data) as OpenWsEnvelope
+}
+
+export function canBindTransport(transport: Transport): boolean {
+    return typeof transport.on === 'function'
+}
+
+export function bindTransport(
+    transport: Transport,
+    handler: RawMessageHandler,
+    options: BindTransportOptions = {}
+): Unsubscribe {
+    const handleData = async (data: unknown) => {
+        try {
+            await handler.handleRawMessage(await normalizeMessageData(data))
+        } catch (error) {
+            await handler.messageError?.(error)
+            if (options.closeOnError) {
+                transport.close?.()
+            }
+        }
+    }
+    const handleSocketError = async (error: unknown) => {
+        await handler.socketError?.(error)
+    }
+
+    const nodeHandler = (data: unknown, ..._args: unknown[]) => {
+        void handleData(data)
+    }
+    const nodeErrorHandler = (error: unknown, ..._args: unknown[]) => {
+        void handleSocketError(error)
+    }
+
+    if (typeof transport.on !== 'function') {
+        throw new Error('Transport must support on("message")')
+    }
+
+    const messageUnsubscribe = transport.on('message', nodeHandler)
+    const errorUnsubscribe = transport.on('error', nodeErrorHandler)
+    return () => {
+        if (typeof messageUnsubscribe === 'function') messageUnsubscribe()
+        if (typeof errorUnsubscribe === 'function') errorUnsubscribe()
+    }
+}
+
+export class WsTransport implements Transport {
+    private socket?: unknown
+    private socketUnsubscribe?: Unsubscribe
+    private openPromise?: Promise<void>
+    private readonly listeners: Record<TransportEvent, Set<TransportHandler>> = {
+        message: new Set(),
+        error: new Set(),
+    }
+
+    constructor(socket?: unknown) {
+        if (socket) {
+            this.bindSocket(socket)
+        }
+    }
+
+    async connect(_roleName: string, endpoint?: OpenWsEndpoint): Promise<void> {
+        if (!this.socket) {
+            if (!endpoint) {
+                throw new Error('Cannot connect without a WebSocket endpoint')
+            }
+            this.bindSocket(createWebSocket(endpoint))
+        }
+        await this.waitForOpen()
+    }
+
+    async disconnect(): Promise<void> {
+        this.close()
+    }
+
+    async send(data: string): Promise<void> {
+        await this.waitForOpen()
+        const socket = this.requireSocket() as { send?: (data: string) => void | Promise<void> }
+        if (typeof socket.send !== 'function') {
+            throw new Error('WebSocket object must support send(data)')
+        }
+        await socket.send(data)
+    }
+
+    on(event: TransportEvent, handler: TransportHandler): Unsubscribe {
+        this.listeners[event].add(handler)
+        return () => {
+            this.listeners[event].delete(handler)
+        }
+    }
+
+    close(): void {
+        const socket = this.socket as { close?: () => void } | undefined
+        socket?.close?.()
+        this.socketUnsubscribe?.()
+        this.socket = undefined
+        this.socketUnsubscribe = undefined
+        this.openPromise = undefined
+    }
+
+    private bindSocket(socket: unknown): void {
+        this.socketUnsubscribe?.()
+        this.socket = socket
+        this.openPromise = undefined
+
+        const unsubscribeMessage = addSocketListener(socket, 'message', data => {
+            void this.emit('message', getMessageEventData(data))
+        })
+        const unsubscribeError = addSocketListener(socket, 'error', error => {
+            void this.emit('error', error)
+        })
+        this.socketUnsubscribe = () => {
+            unsubscribeMessage()
+            unsubscribeError()
+        }
+    }
+
+    private async emit(event: TransportEvent, data: unknown): Promise<void> {
+        for (const handler of this.listeners[event]) {
+            await handler(data)
+        }
+    }
+
+    private requireSocket(): unknown {
+        if (!this.socket) {
+            throw new Error('WebSocket is not connected')
+        }
+        return this.socket
+    }
+
+    private async waitForOpen(): Promise<void> {
+        const socket = this.requireSocket()
+        const readyState = getReadyState(socket)
+        if (readyState === undefined || readyState === 1) return
+        if (readyState === 2 || readyState === 3) {
+            throw new Error('WebSocket is closed')
+        }
+
+        this.openPromise ??= new Promise<void>((resolve, reject) => {
+            let cleanup: Unsubscribe = () => {}
+            const unsubscribeOpen = addSocketListener(socket, 'open', () => {
+                cleanup()
+                resolve()
+            })
+            const unsubscribeError = addSocketListener(socket, 'error', error => {
+                cleanup()
+                reject(error)
+            })
+            cleanup = () => {
+                unsubscribeOpen()
+                unsubscribeError()
+            }
+        })
+        await this.openPromise
+    }
+}
+
+async function normalizeMessageData(data: unknown): Promise<string> {
+    if (typeof data === 'string') return data
+    if (data instanceof ArrayBuffer) return new TextDecoder().decode(data)
+    if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data)
+    if (typeof Blob !== 'undefined' && data instanceof Blob) return await data.text()
+    return String(data)
+}
+
+function getMessageEventData(event: unknown): unknown {
+    if (event && typeof event === 'object' && 'data' in event) {
+        return (event as { data: unknown }).data
+    }
+    return event
+}
+
+function createWebSocket(endpoint: OpenWsEndpoint): unknown {
+    const WebSocketCtor = (globalThis as { WebSocket?: new (url: string) => unknown }).WebSocket
+    if (!WebSocketCtor) {
+        throw new Error('No global WebSocket constructor found. Pass a socket or custom Transport to the client.')
+    }
+    return new WebSocketCtor(endpointToUrl(endpoint))
+}
+
+function endpointToUrl(endpoint: OpenWsEndpoint): string {
+    const scheme = endpoint.scheme || 'ws'
+    const host = endpoint.host || 'localhost'
+    const port = endpoint.port === undefined ? '' : `:${endpoint.port}`
+    const path = endpoint.path ? (endpoint.path.startsWith('/') ? endpoint.path : `/${endpoint.path}`) : ''
+    return `${scheme}://${host}${port}${path}`
+}
+
+function getReadyState(socket: unknown): number | undefined {
+    const readyState = (socket as { readyState?: unknown }).readyState
+    return typeof readyState === 'number' ? readyState : undefined
+}
+
+function addSocketListener(
+    socket: unknown,
+    event: 'open' | 'message' | 'error',
+    handler: (...args: unknown[]) => void
+): Unsubscribe {
+    const target = socket as {
+        on?: (event: string, handler: (...args: unknown[]) => void) => unknown
+        off?: (event: string, handler: (...args: unknown[]) => void) => unknown
+        removeListener?: (event: string, handler: (...args: unknown[]) => void) => unknown
+        addEventListener?: (event: string, handler: (event: unknown) => void) => unknown
+        removeEventListener?: (event: string, handler: (event: unknown) => void) => unknown
+        [key: string]: unknown
+    }
+
+    if (typeof target.on === 'function') {
+        target.on(event, handler)
+        return () => {
+            if (typeof target.off === 'function') target.off(event, handler)
+            else if (typeof target.removeListener === 'function') target.removeListener(event, handler)
+        }
+    }
+
+    if (typeof target.addEventListener === 'function') {
+        const eventHandler = (event: unknown) => {
+            handler(event)
+        }
+        target.addEventListener(event, eventHandler)
+        return () => {
+            target.removeEventListener?.(event, eventHandler)
+        }
+    }
+
+    const propertyName = `on${event}`
+    const previous = target[propertyName]
+    const next = (...args: unknown[]) => {
+        if (typeof previous === 'function') {
+            previous(...args)
+        }
+        handler(...args)
+    }
+    target[propertyName] = next
+    return () => {
+        if (target[propertyName] === next) {
+            target[propertyName] = previous
+        }
+    }
+}
+<% } else { -%>
+export function encodeEnvelope(envelope) {
+    return JSON.stringify(envelope)
+}
+
+export function decodeEnvelope(data) {
+    return JSON.parse(data)
+}
+
+export function canBindTransport(transport) {
+    return typeof transport.on === 'function'
+}
+
+export function bindTransport(transport, handler, options = {}) {
+    const handleData = async data => {
+        try {
+            await handler.handleRawMessage(await normalizeMessageData(data))
+        } catch (error) {
+            await handler.messageError?.(error)
+            if (options.closeOnError) {
+                transport.close?.()
+            }
+        }
+    }
+    const handleSocketError = async error => {
+        await handler.socketError?.(error)
+    }
+
+    const nodeHandler = data => {
+        void handleData(data)
+    }
+    const nodeErrorHandler = error => {
+        void handleSocketError(error)
+    }
+
+    if (typeof transport.on !== 'function') {
+        throw new Error('Transport must support on("message")')
+    }
+
+    const messageUnsubscribe = transport.on('message', nodeHandler)
+    const errorUnsubscribe = transport.on('error', nodeErrorHandler)
+    return () => {
+        if (typeof messageUnsubscribe === 'function') messageUnsubscribe()
+        if (typeof errorUnsubscribe === 'function') errorUnsubscribe()
+    }
+}
+
+export class WsTransport {
+    socket
+    socketUnsubscribe
+    openPromise
+    listeners = {
+        message: new Set(),
+        error: new Set(),
+    }
+
+    constructor(socket) {
+        if (socket) {
+            this.bindSocket(socket)
+        }
+    }
+
+    async connect(_roleName, endpoint) {
+        if (!this.socket) {
+            if (!endpoint) {
+                throw new Error('Cannot connect without a WebSocket endpoint')
+            }
+            this.bindSocket(createWebSocket(endpoint))
+        }
+        await this.waitForOpen()
+    }
+
+    async disconnect() {
+        this.close()
+    }
+
+    async send(data) {
+        await this.waitForOpen()
+        const socket = this.requireSocket()
+        if (typeof socket.send !== 'function') {
+            throw new Error('WebSocket object must support send(data)')
+        }
+        await socket.send(data)
+    }
+
+    on(event, handler) {
+        this.listeners[event].add(handler)
+        return () => {
+            this.listeners[event].delete(handler)
+        }
+    }
+
+    close() {
+        this.socket?.close?.()
+        this.socketUnsubscribe?.()
+        this.socket = undefined
+        this.socketUnsubscribe = undefined
+        this.openPromise = undefined
+    }
+
+    bindSocket(socket) {
+        this.socketUnsubscribe?.()
+        this.socket = socket
+        this.openPromise = undefined
+
+        const unsubscribeMessage = addSocketListener(socket, 'message', data => {
+            void this.emit('message', getMessageEventData(data))
+        })
+        const unsubscribeError = addSocketListener(socket, 'error', error => {
+            void this.emit('error', error)
+        })
+        this.socketUnsubscribe = () => {
+            unsubscribeMessage()
+            unsubscribeError()
+        }
+    }
+
+    async emit(event, data) {
+        for (const handler of this.listeners[event]) {
+            await handler(data)
+        }
+    }
+
+    requireSocket() {
+        if (!this.socket) {
+            throw new Error('WebSocket is not connected')
+        }
+        return this.socket
+    }
+
+    async waitForOpen() {
+        const socket = this.requireSocket()
+        const readyState = getReadyState(socket)
+        if (readyState === undefined || readyState === 1) return
+        if (readyState === 2 || readyState === 3) {
+            throw new Error('WebSocket is closed')
+        }
+
+        this.openPromise ??= new Promise((resolve, reject) => {
+            let cleanup = () => {}
+            const unsubscribeOpen = addSocketListener(socket, 'open', () => {
+                cleanup()
+                resolve()
+            })
+            const unsubscribeError = addSocketListener(socket, 'error', error => {
+                cleanup()
+                reject(error)
+            })
+            cleanup = () => {
+                unsubscribeOpen()
+                unsubscribeError()
+            }
+        })
+        await this.openPromise
+    }
+}
+
+async function normalizeMessageData(data) {
+    if (typeof data === 'string') return data
+    if (data instanceof ArrayBuffer) return new TextDecoder().decode(data)
+    if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data)
+    if (typeof Blob !== 'undefined' && data instanceof Blob) return await data.text()
+    return String(data)
+}
+
+function getMessageEventData(event) {
+    if (event && typeof event === 'object' && 'data' in event) {
+        return event.data
+    }
+    return event
+}
+
+function createWebSocket(endpoint) {
+    const WebSocketCtor = globalThis.WebSocket
+    if (!WebSocketCtor) {
+        throw new Error('No global WebSocket constructor found. Pass a socket or custom Transport to the client.')
+    }
+    return new WebSocketCtor(endpointToUrl(endpoint))
+}
+
+function endpointToUrl(endpoint) {
+    const scheme = endpoint.scheme || 'ws'
+    const host = endpoint.host || 'localhost'
+    const port = endpoint.port === undefined ? '' : `:${endpoint.port}`
+    const path = endpoint.path ? (endpoint.path.startsWith('/') ? endpoint.path : `/${endpoint.path}`) : ''
+    return `${scheme}://${host}${port}${path}`
+}
+
+function getReadyState(socket) {
+    return typeof socket.readyState === 'number' ? socket.readyState : undefined
+}
+
+function addSocketListener(socket, event, handler) {
+    if (typeof socket.on === 'function') {
+        socket.on(event, handler)
+        return () => {
+            if (typeof socket.off === 'function') socket.off(event, handler)
+            else if (typeof socket.removeListener === 'function') socket.removeListener(event, handler)
+        }
+    }
+
+    if (typeof socket.addEventListener === 'function') {
+        const eventHandler = event => {
+            handler(event)
+        }
+        socket.addEventListener(event, eventHandler)
+        return () => {
+            socket.removeEventListener?.(event, eventHandler)
+        }
+    }
+
+    const propertyName = `on${event}`
+    const previous = socket[propertyName]
+    const next = (...args) => {
+        if (typeof previous === 'function') {
+            previous(...args)
+        }
+        handler(...args)
+    }
+    socket[propertyName] = next
+    return () => {
+        if (socket[propertyName] === next) {
+            socket[propertyName] = previous
+        }
+    }
+}
+<% } -%>

package/dist/templates/typescript/src/core/roles/index.ts.ejs

@@ -0,0 +1,3 @@
+<% for (const role of ctx.roles) { -%>
+export * from './<%= role.fileName %><%= ctx.isTypeScript ? '' : '.js' %>'
+<% } -%>

package/dist/templates/typescript/src/core/roles/role.ts.ejs

@@ -0,0 +1,104 @@
+<% const modelImportPath = ctx.isTypeScript ? `../models/${ctx.fileName}` : `../models/${ctx.fileName}/index.js` -%>
+<% if (ctx.isTypeScript) { -%>
+<% if (ctx.messages.length > 0) { -%>
+import type {
+<% for (const message of ctx.messages) { -%>
+    <%= message.payloadType %>,
+    <%= message.payloadType %>Init,
+<% } -%>
+} from '<%= modelImportPath %>'
+<% } -%>
+<% const importedPeerRoles = new Map(); for (const message of ctx.messages) { for (const fromRole of message.fromRoles ?? []) { if (fromRole.roleName !== ctx.roleName) importedPeerRoles.set(fromRole.roleName, fromRole) } } -%>
+<% if (importedPeerRoles.size > 0) { -%>
+import {
+<% for (const fromRole of importedPeerRoles.values()) { -%>
+    <%= fromRole.roleClassName %>,
+<% } -%>
+} from './index'
+<% } -%>
+
+export interface <%= ctx.apiName %> {
+<% for (const message of ctx.messages) { -%>
+    <%= message.methodName %>(payload: <%= message.payloadType %> | <%= message.payloadType %>Init): Promise<void>
+<% } -%>
+}
+
+export class <%= ctx.roleClassName %> {
+    static readonly CONFIG = {
+        name: <%- JSON.stringify(ctx.roleName) %>,
+        description: <%- JSON.stringify(ctx.description) %>,
+        messages: {
+<% for (const message of ctx.messages) { -%>
+            <%= message.messageName %>: {
+                payload: <%- JSON.stringify(message.schema, null, 16) %>,
+            },
+<% } -%>
+        },
+    }
+    static readonly endpoints = <%- JSON.stringify(ctx.endpoints, null, 4) %>
+}
+
+export class <%= ctx.hostRoleClassName %> {
+    static get CONFIG() {
+        return {
+            name: <%- JSON.stringify(ctx.roleName) %>,
+            description: <%- JSON.stringify(ctx.description) %>,
+            handlers: {
+<% for (const message of ctx.messages) { -%>
+                <%= message.messageName %>: {
+                    payload: <%= ctx.roleClassName %>.CONFIG.messages.<%= message.messageName %>.payload,
+<% if (message.fromRoles) { -%>
+                    from: [<%= message.fromRoles.map(fromRole => fromRole.roleClassName).join(', ') %>],
+<% } -%>
+                },
+<% } -%>
+            },
+            endpoints: <%= ctx.roleClassName %>.endpoints,
+        }
+    }
+}
+<% } else { -%>
+<% const importedPeerRoles = new Map(); for (const message of ctx.messages) { for (const fromRole of message.fromRoles ?? []) { if (fromRole.roleName !== ctx.roleName) importedPeerRoles.set(fromRole.roleName, fromRole) } } -%>
+<% if (importedPeerRoles.size > 0) { -%>
+import {
+<% for (const fromRole of importedPeerRoles.values()) { -%>
+    <%= fromRole.roleClassName %>,
+<% } -%>
+} from './index.js'
+<% } -%>
+
+export class <%= ctx.roleClassName %> {
+    static CONFIG = {
+        name: <%- JSON.stringify(ctx.roleName) %>,
+        description: <%- JSON.stringify(ctx.description) %>,
+        messages: {
+<% for (const message of ctx.messages) { -%>
+            <%= message.messageName %>: {
+                payload: <%- JSON.stringify(message.schema, null, 16) %>,
+            },
+<% } -%>
+        },
+    }
+    static endpoints = <%- JSON.stringify(ctx.endpoints, null, 4) %>
+}
+
+export class <%= ctx.hostRoleClassName %> {
+    static get CONFIG() {
+        return {
+            name: <%- JSON.stringify(ctx.roleName) %>,
+            description: <%- JSON.stringify(ctx.description) %>,
+            handlers: {
+<% for (const message of ctx.messages) { -%>
+                <%= message.messageName %>: {
+                    payload: <%= ctx.roleClassName %>.CONFIG.messages.<%= message.messageName %>.payload,
+<% if (message.fromRoles) { -%>
+                    from: [<%= message.fromRoles.map(fromRole => fromRole.roleClassName).join(', ') %>],
+<% } -%>
+                },
+<% } -%>
+            },
+            endpoints: <%= ctx.roleClassName %>.endpoints,
+        }
+    }
+}
+<% } -%>

package/dist/templates/typescript/src/index.ts.ejs

@@ -0,0 +1,4 @@
+<% for (const network of ctx.networkExports) { -%>
+export * as <%= network.exportName %> from './<%= network.fileName %><%= ctx.isTypeScript ? '' : '/index.js' %>'
+<% } -%>
+export * as sdk from './sdk<%= ctx.isTypeScript ? '' : '/index.js' %>'

package/dist/templates/typescript/src/sdk/index.ts.ejs

@@ -0,0 +1,3 @@
+<% for (const role of ctx.roles) { -%>
+export * from './<%= role.fileName %><%= ctx.isTypeScript ? '' : '.js' %>'
+<% } -%>