@polytric/openws-sdkgen 0.0.4 → 0.0.6

package/dist/templates/typescript/package.json.ejs

@@ -0,0 +1,41 @@
+{
+    "name": <%- JSON.stringify(ctx.packageName) %>,
+    "version": <%- JSON.stringify(ctx.version) %>,
+    "description": <%- JSON.stringify(ctx.description ?? '') %>,
+    "type": "module",
+<% if (ctx.isTypeScript) { -%>
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "dependencies": {
+        "@polytric/openws": "^0.0.4"
+    },
+    "scripts": {
+        "build": "tsup",
+        "typecheck": "tsc --noEmit"
+    },
+    "devDependencies": {
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3"
+    }
+<% } else { -%>
+    "main": "./src/index.js",
+    "exports": {
+        ".": "./src/index.js"
+    },
+    "files": [
+        "src"
+    ],
+    "dependencies": {
+        "@polytric/openws": "^0.0.4"
+    }
+<% } -%>
+}

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

@@ -0,0 +1,6 @@
+export * from './network<%= ctx.isTypeScript ? '' : '.js' %>'
+export * from './roles<%= ctx.isTypeScript ? '' : '/index.js' %>'
+export * as roles from './roles<%= ctx.isTypeScript ? '' : '/index.js' %>'
+<% for (const modelScope of ctx.modelScopes) { -%>
+export * as <%= modelScope.varName %>Models from './models/<%= modelScope.fileName %><%= ctx.isTypeScript ? '' : '/index.js' %>'
+<% } -%>

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

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

package/dist/templates/typescript/src/core/models/model.ts.ejs

@@ -0,0 +1,41 @@
+<% if (ctx.isTypeScript) { -%>
+<% for (const modelImport of ctx.imports) { -%>
+import type { <%= modelImport.className %> } from './<%= modelImport.fileName %>'
+<% } -%>
+<% if (ctx.imports.length > 0) { -%>
+
+<% } -%>
+export interface <%= ctx.className %>Init {
+<% for (const property of ctx.properties) { -%>
+    <%= property.name %><%= property.optional ? '?' : '' %>: <%= property.typeName %>
+<% } -%>
+}
+
+export class <%= ctx.className %> implements <%= ctx.className %>Init {
+<% for (const property of ctx.properties) { -%>
+    readonly <%= property.name %><%= property.optional ? '?' : '' %>: <%= property.typeName %>
+<% } -%>
+
+    constructor({
+<% for (const property of ctx.properties) { -%>
+        <%= property.name %>,
+<% } -%>
+    }: <%= ctx.className %>Init = {} as <%= ctx.className %>Init) {
+<% for (const property of ctx.properties) { -%>
+        this.<%= property.name %> = <%= property.name %>
+<% } -%>
+    }
+}
+<% } else { -%>
+export class <%= ctx.className %> {
+    constructor({
+<% for (const property of ctx.properties) { -%>
+        <%= property.name %>,
+<% } -%>
+    } = {}) {
+<% for (const property of ctx.properties) { -%>
+        this.<%= property.name %> = <%= property.name %>
+<% } -%>
+    }
+}
+<% } -%>

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' %>'
+<% } -%>