@flock/wirespec 0.17.20 → 0.18.1-RC.2

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@flock/wirespec",
-  "version": "0.17.20",
+  "version": "0.18.1-RC.2",
   "main": "wirespec-src-plugin-npm.mjs",
-  "types": "wirespec-src-plugin-npm.d.ts",
+  "types": "wirespec-src-plugin-npm.d.mts",
   "devDependencies": {
-    "typescript": "5.5.4",
-    "source-map-support": "0.5.21"
-  },
-  "dependencies": {
-    "format-util": "^1.0.5"
+    "typescript": "5.9.3"
   },
+  "dependencies": {},
   "peerDependencies": {},
   "optionalDependencies": {},
   "bundledDependencies": [],

package/seskar-core.mjs

@@ -0,0 +1,4 @@
+//region block: pre-declaration
+//endregion
+
+//# sourceMappingURL=seskar-core.mjs.map

package/seskar-core.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;"}

package/wirespec-bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import {cli} from "./wirespec-src-plugin-cli.mjs";
+import {cli} from "./wirespec-src-plugin-npm.mjs";
 
 // https://github.com/Kotlin/kotlinx-io/issues/345
 import os from "node:os";
@@ -15,4 +15,16 @@ global.require = function require(input) {
     }
 }
 
+// Workaround: Clikt's ES modules have a circular dependency (clikt-core imports
+// selfAndAncestors from clikt-mordant, while clikt-mordant imports CoreCliktCommand
+// from clikt-core). This causes CliktCommand's prototype to chain to a stale
+// CoreCliktCommand prototype instead of the properly initialized one.
+import * as cliktCore from "./clikt-clikt.mjs";
+import * as cliktMordant from "./clikt-clikt-mordant.mjs";
+const CoreCC = Object.values(cliktCore).find(v => typeof v === 'function' && v.name === 'CoreCliktCommand');
+const CC = Object.values(cliktMordant).find(v => typeof v === 'function' && v.name === 'CliktCommand');
+if (CoreCC && CC && Object.getPrototypeOf(CC.prototype) !== CoreCC.prototype) {
+    Object.setPrototypeOf(CC.prototype, CoreCC.prototype);
+}
+
 cli(process.argv.slice(2))

package/wirespec-fetch.d.ts

@@ -1,6 +1,9 @@
 export type Method = "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD" | "PATCH" | "TRACE"
 export type RawRequest = { method: Method, path: string[], queries: Record<string, string>, headers: Record<string, string>, body?: string }
+export type RawRequestIr = { method: string, path: string[], queries: Record<string, string[]>, headers: Record<string, string[]>, body: Uint8Array | undefined }
 export type RawResponse = { status: number, headers: Record<string, string>, body?: string }
+export type RawResponseIr = { statusCode:number, headers: Record<string, string[]>, body: Uint8Array | undefined }
 export type HandleFetch = ( path:string, init?:RequestInit) => Promise<Response>
 
-export declare function wirespecFetch  (rawRequest:RawRequest, handle?: HandleFetch): Promise<RawResponse>
+export declare function wirespecFetch  (rawRequest:(RawRequest), handle?: HandleFetch): Promise<RawResponse>
+export declare function wirespecFetchIr  (rawRequest:(RawRequestIr), handle?: HandleFetch): Promise<RawResponseIr>

package/wirespec-fetch.mjs

@@ -31,3 +31,37 @@ export async function wirespecFetch(req, handler) {
     };
 
 }
+
+export async function wirespecFetchIr(req, handler) {
+    const contentHeader = req.body ? { 'Content-Type': 'application/json' } : {};
+    const body = req.body !== undefined ? req.body : undefined;
+    const query = Object.entries(req.queries)
+        .filter(([_, value]) => value !== undefined)
+        .flatMap(([key, value]) => {
+            if (value && typeof value === 'string' && value.startsWith('[') && value.endsWith(']')) {
+                const parsedValue = JSON.parse(value);
+                if (Array.isArray(parsedValue)) {
+                    return parsedValue.map((item) => `${key}=${item}`);
+                }
+            }
+            return `${key}=${value}`;
+        })
+        .join('&');
+    const path = req.path
+        .map(segment => encodeURIComponent(segment))
+        .join('/')
+    const url = `/${path}${query ? `?${query}` : ''}`;
+    const init = {method: req.method, body, headers: {...req.headers, ...contentHeader}}
+    const res = handler ? await handler(url, init) : await fetch(url, init)
+    const contentType = res.headers.get('Content-Type');
+    const contentLength = res.headers.get('Content-Length');
+    return {
+        statusCode: res.status,
+        headers: {
+            ...[...res.headers.entries()].reduce((acc, [key, value]) => ({...acc, [key]: [value]}), {}),
+            'Content-Type': [contentType],
+        },
+        body: contentLength !== '0' && contentType ? await res.text() : undefined,
+    };
+
+}

package/wirespec-serialization.d.ts

@@ -1,3 +1,14 @@
-export type Serialization = { serialize: <T>(typed: T) => string; deserialize: <T>(raw: string | undefined) => T }
+export type Type = string
 
-export const wirespecSerialization: Serialization
+export interface Serialization {
+    serialize<T>(typed: T): string;
+    deserialize<T>(raw: string | undefined): T;
+    serializeBody<T>(t: T, type: Type): Uint8Array;
+    deserializeBody<T>(raw: Uint8Array, type: Type): T;
+    serializePath<T>(t: T, type: Type): string;
+    deserializePath<T>(raw: string, type: Type): T;
+    serializeParam<T>(value: T, type: Type): string[];
+    deserializeParam<T>(values: string[], type: Type): T;
+}
+
+export declare const wirespecSerialization: Serialization

package/wirespec-serialization.mjs

@@ -1,3 +1,6 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
 export const wirespecSerialization = {
     deserialize(raw) {
         if (raw === undefined) {
@@ -14,4 +17,22 @@ export const wirespecSerialization = {
 
         return JSON.stringify(type);
     },
-};
+    serializeBody(t, _type) {
+        return encoder.encode(JSON.stringify(t));
+    },
+    deserializeBody(raw, _type) {
+        return JSON.parse(decoder.decode(raw));
+    },
+    serializePath(t, _type) {
+        return String(t);
+    },
+    deserializePath(raw, _type) {
+        return raw;
+    },
+    serializeParam(value, _type) {
+        return Array.isArray(value) ? value.map(String) : [String(value)];
+    },
+    deserializeParam(values, _type) {
+        return values[0];
+    },
+};