@trypattern/sdk 0.1.31 → 0.1.33

package/dist/serviceClients.js

@@ -1,5 +1,8 @@
+import { pickedFile, pickedFileOf } from "./files.js";
 import { MemoryServer } from "./memoryApi.js";
 import { ServiceRefused, paramNamesOf } from "./services.js";
+const FILE_GONE = 'Choose the file again.';
+const NOT_SENT = 'Couldn’t send it. Check your connection and try again.';
 function buildClient(services, make) {
     return Object.fromEntries(Object.entries(services).map(([group, calls]) => [
         group,
@@ -21,38 +24,109 @@ function errorOf(body, status) {
         : undefined;
     return typeof error === 'string' ? error : `HTTP ${status}`;
 }
-export function httpServices(services, gate, onSignedOut) {
-    return buildClient(services, (group, name, call) => (input = {}) => gate.pass(`${group}.${name}`, async () => {
-        const { path, rest } = splitInput(call, input);
-        const sent = call.input.parse(rest);
-        const fields = Object.entries(sent).filter(([, value]) => value !== undefined);
-        const query = call.method === 'get' && fields.length > 0
-            ? `?${new URLSearchParams(fields.map(([key, value]) => [key, String(value)])).toString()}`
-            : '';
-        const response = await fetch(`/api${path}${query}`, {
-            method: call.method.toUpperCase(),
-            ...(call.method === 'post'
-                ? {
-                    headers: { 'content-type': 'application/json' },
-                    body: JSON.stringify(sent)
-                }
-                : {})
+function fileIdOf(input) {
+    const file = input['file'];
+    const id = typeof file === 'object' && file !== null
+        ? Reflect.get(file, 'id')
+        : undefined;
+    return typeof id === 'string' ? id : '';
+}
+function formOf(fields, file) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined)
+            form.set(key, String(value));
+    }
+    form.set('file', file, file.name);
+    return form;
+}
+function bodyOf(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function sendForm(url, form, { onProgress, signal }) {
+    return new Promise((resolve, reject) => {
+        const request = new XMLHttpRequest();
+        const abort = () => request.abort();
+        request.open('POST', url);
+        request.upload.addEventListener('progress', (event) => {
+            if (event.lengthComputable)
+                onProgress?.(event.loaded, event.total);
         });
-        const body = await response.json().catch(() => null);
-        if (response.status === 401)
+        request.addEventListener('load', () => {
+            signal?.removeEventListener('abort', abort);
+            resolve({ status: request.status, body: bodyOf(request.responseText) });
+        });
+        request.addEventListener('error', () => {
+            signal?.removeEventListener('abort', abort);
+            reject(new ServiceRefused(0, NOT_SENT));
+        });
+        request.addEventListener('abort', () => {
+            reject(new DOMException('The upload was cancelled', 'AbortError'));
+        });
+        if (signal?.aborted === true) {
+            reject(new DOMException('The upload was cancelled', 'AbortError'));
+            return;
+        }
+        signal?.addEventListener('abort', abort);
+        request.send(form);
+    });
+}
+async function upload(call, input, options) {
+    const { path, rest } = splitInput(call, input);
+    const file = pickedFileOf(fileIdOf(input));
+    if (file === undefined)
+        throw new ServiceRefused(400, FILE_GONE);
+    const fields = call.input.parse(Object.fromEntries(Object.entries(rest).filter(([key]) => key !== 'file')));
+    return sendForm(`/api${path}`, formOf(fields, file), options);
+}
+async function request(call, input) {
+    const { path, rest } = splitInput(call, input);
+    const sent = call.input.parse(rest);
+    const fields = Object.entries(sent).filter(([, value]) => value !== undefined);
+    const query = call.method === 'get' && fields.length > 0
+        ? `?${new URLSearchParams(fields.map(([key, value]) => [key, String(value)])).toString()}`
+        : '';
+    const response = await fetch(`/api${path}${query}`, {
+        method: call.method.toUpperCase(),
+        ...(call.method === 'post'
+            ? {
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(sent)
+            }
+            : {})
+    });
+    return {
+        status: response.status,
+        body: await response.json().catch(() => null)
+    };
+}
+export function httpServices(services, gate, onSignedOut) {
+    return buildClient(services, (group, name, call) => (input = {}, options = {}) => gate.pass(`${group}.${name}`, async () => {
+        const { status, body } = call.isUpload
+            ? await upload(call, input, options)
+            : await request(call, input);
+        if (status === 401)
             onSignedOut();
-        if (!response.ok) {
-            throw new ServiceRefused(response.status, errorOf(body, response.status));
+        if (status < 200 || status >= 300) {
+            throw new ServiceRefused(status, errorOf(body, status));
         }
         return call.reply.parse(body);
     }));
 }
 export function memoryServices(services, memory, world, options) {
     const servers = new Map();
-    return buildClient(services, (group, name, call) => (input = {}) => {
+    return buildClient(services, (group, name, call) => (input = {}, upload = {}) => {
         const server = servers.get(group) ?? new MemoryServer(group, options);
         servers.set(group, server);
         return server.reply(name, () => {
+            if (upload.signal?.aborted === true) {
+                throw new DOMException('The upload was cancelled', 'AbortError');
+            }
             const handlers = Reflect.get(memory, group);
             const handler = typeof handlers === 'object' && handlers !== null
                 ? Reflect.get(handlers, name)
@@ -61,8 +135,18 @@ export function memoryServices(services, memory, world, options) {
                 throw new Error(`The memory fake has no ${group}.${name}`);
             }
             const { rest } = splitInput(call, input);
-            const params = Object.fromEntries(paramNamesOf(call.path).map((key) => [key, String(input[key] ?? '')]));
-            return call.reply.parse(handler(world, { ...params, ...call.input.parse(rest) }));
+            const params = Object.fromEntries(paramNamesOf(call.path).map((key) => [
+                key,
+                String(input[key] ?? '')
+            ]));
+            const file = call.isUpload
+                ? pickedFile.parse(input['file'])
+                : undefined;
+            return call.reply.parse(handler(world, {
+                ...params,
+                ...call.input.parse(rest),
+                ...(file === undefined ? {} : { file })
+            }));
         });
     });
 }

package/dist/services.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type { PickedFile } from './files.ts';
 import type { SameOnTheWire } from './wire.ts';
 type Shape = z.ZodRawShape;
 type NoShape = Record<never, never>;
@@ -6,11 +7,16 @@ type ParamNames<Path extends string> = Path extends `${string}:${infer Param}/${
 export type ParamsOf<Path extends string> = {
     readonly [Name in ParamNames<Path>]: string;
 };
-export type ServiceCall<Path extends string = string, S extends Shape = Shape, Reply extends z.ZodType = z.ZodType> = {
+export type ServiceCall<Path extends string = string, S extends Shape = Shape, Reply extends z.ZodType = z.ZodType, Upload extends boolean = boolean> = {
     readonly method: 'get' | 'post';
     readonly path: Path;
     readonly input: z.ZodObject<S>;
     readonly reply: Reply;
+    readonly isUpload: Upload;
+};
+export type UploadOptions = {
+    readonly onProgress?: (sent: number, total: number) => void;
+    readonly signal?: AbortSignal;
 };
 type StaticTypeError<Message extends string> = Message;
 type NotText = StaticTypeError<'A get call sends its input in the address, where everything is text: use z.string() or z.enum() here, or make it a post call'>;
@@ -26,12 +32,30 @@ type CallOptions<Path extends string, S extends Shape, Reply extends z.ZodType>
     input?: SameOnTheWire<S>;
     reply: Reply;
 };
-export declare function call<Path extends string, Reply extends z.ZodType, S extends Shape = NoShape>(options: CallOptions<Path, S, Reply>): NoInfer<ServiceCall<Path, S, Reply>>;
+type UploadCallOptions<Path extends string, S extends Shape, Reply extends z.ZodType> = {
+    upload: Path;
+    input?: TextOnly<S> & SameOnTheWire<S>;
+    reply: Reply;
+};
+export declare function call<Path extends string, Reply extends z.ZodType, S extends Shape = NoShape>(options: UploadCallOptions<Path, S, Reply>): NoInfer<ServiceCall<Path, S, Reply, true>>;
+export declare function call<Path extends string, Reply extends z.ZodType, S extends Shape = NoShape>(options: CallOptions<Path, S, Reply>): NoInfer<ServiceCall<Path, S, Reply, false>>;
 export type Services = Readonly<Record<string, Readonly<Record<string, ServiceCall>>>>;
 export declare function defineServices<const Group extends Services>(services: Group): Group;
-export type CallInput<Call> = Call extends ServiceCall<infer Path, infer S, z.ZodType> ? ParamsOf<Path> & (keyof S extends never ? NoShape : z.output<z.ZodObject<S>>) : never;
+type FieldsOf<Call> = Call extends ServiceCall<infer Path, infer S, z.ZodType> ? ParamsOf<Path> & (keyof S extends never ? NoShape : z.output<z.ZodObject<S>>) : never;
+export type CallInput<Call> = FieldsOf<Call> & (Call extends {
+    readonly isUpload: true;
+} ? {
+    file: PickedFile;
+} : NoShape);
+export type HandlerInput<Call> = FieldsOf<Call> & (Call extends {
+    readonly isUpload: true;
+} ? {
+    file: File;
+} : NoShape);
 export type CallReply<Call> = Call extends ServiceCall<string, Shape, infer Reply> ? z.output<Reply> : never;
-type ClientCall<Call> = keyof CallInput<Call> extends never ? (input?: CallInput<Call>) => Promise<CallReply<Call>> : (input: CallInput<Call>) => Promise<CallReply<Call>>;
+type ClientCall<Call> = Call extends {
+    readonly isUpload: true;
+} ? (input: CallInput<Call>, options?: UploadOptions) => Promise<CallReply<Call>> : keyof CallInput<Call> extends never ? (input?: CallInput<Call>) => Promise<CallReply<Call>> : (input: CallInput<Call>) => Promise<CallReply<Call>>;
 export type ServiceClient<Group extends Services> = {
     readonly [Name in keyof Group]: {
         readonly [Call in keyof Group[Name]]: ClientCall<Group[Name][Call]>;

package/dist/services.js

@@ -1,12 +1,16 @@
 import { z } from 'zod';
 export function call(options) {
-    const method = 'get' in options ? 'get' : 'post';
-    const path = 'get' in options ? options.get : options.post;
+    const path = 'get' in options
+        ? options.get
+        : 'post' in options
+            ? options.post
+            : options.upload;
     return {
-        method,
+        method: 'get' in options ? 'get' : 'post',
         path,
         input: z.object((options.input ?? {})),
-        reply: options.reply
+        reply: options.reply,
+        isUpload: 'upload' in options
     };
 }
 export function defineServices(services) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "type": "module",
   "files": [
     "dist",