@cripty2001/utils 0.0.244 → 0.0.246

package/dist/Appserver/client.d.ts

@@ -1,41 +1 @@
-import { Whispr } from "@cripty2001/whispr";
-import { AppserverData } from "./common";
-export type { AppserverData };
-export type ClientCreateOptions = {
-    rpcMount: string;
-};
-export declare class ClientError extends Error {
-    constructor(message: string);
-}
-export declare class ClientAuthError extends ClientError {
-    readonly code: string;
-    readonly payload: AppserverData;
-    constructor(code?: string, message?: string, payload?: AppserverData);
-}
-export declare class ClientServerError extends ClientError {
-    code: string;
-    payload: AppserverData;
-    constructor(code: string, message: string, payload?: AppserverData);
-}
-type ClientValidationErrorError = {
-    path: string;
-    message: string;
-    value: unknown;
-};
-export declare class ClientValidationError extends ClientError {
-    readonly errors: ClientValidationErrorError[];
-    constructor(errors: ClientValidationErrorError[]);
-}
-export declare class Client {
-    private url;
-    private readonly rpcMount;
-    private readonly token;
-    private readonly setToken;
-    readonly loggedIn: Whispr<boolean>;
-    private constructor();
-    static create(url: string, options: ClientCreateOptions): Client;
-    login(token: string): Promise<boolean>;
-    logout(): void;
-    exec<I extends AppserverData, O extends AppserverData>(action: string, input: I, onError?: Record<string, (payload: AppserverData) => Promise<void>>): Promise<O>;
-    private unsafeExec;
-}
+export {};

package/dist/Appserver/client.js

@@ -1,127 +1,147 @@
 "use strict";
+// import { Whispr, WhisprSetter } from "@cripty2001/whispr";
+// import { decode, encode } from "@msgpack/msgpack";
+// import { AppserverData } from "./common";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.ClientValidationError = exports.ClientServerError = exports.ClientAuthError = exports.ClientError = void 0;
-const whispr_1 = require("@cripty2001/whispr");
-const msgpack_1 = require("@msgpack/msgpack");
-class ClientError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-exports.ClientError = ClientError;
-class ClientAuthError extends ClientError {
-    code;
-    payload;
-    constructor(code = "PERMISSION_DENIED", message = "Permission denied", payload = {}) {
-        super(message);
-        this.code = code;
-        this.payload = payload;
-    }
-}
-exports.ClientAuthError = ClientAuthError;
-class ClientServerError extends ClientError {
-    code;
-    payload;
-    constructor(code, message, payload = {}) {
-        super(message);
-        this.code = code;
-        this.payload = payload;
-    }
-}
-exports.ClientServerError = ClientServerError;
-class ClientValidationError extends ClientError {
-    errors;
-    constructor(errors) {
-        const first = errors[0] ?? {
-            path: "Internal Error",
-            message: "",
-            value: undefined,
-        };
-        super(`[Validation Error] ${first.path}: ${first.message}`);
-        this.errors = errors;
-    }
-}
-exports.ClientValidationError = ClientValidationError;
-class Client {
-    url;
-    rpcMount;
-    token;
-    setToken;
-    loggedIn;
-    constructor(url, rpcMount) {
-        this.url = url;
-        this.rpcMount = rpcMount;
-        const [token, setToken] = whispr_1.Whispr.create(''); // This will make sure the loggedin only flips to false when there is really an auth rejected. Server will ignore invalid tokens on public apis anyway
-        this.token = token;
-        this.setToken = setToken;
-        this.loggedIn = token.transform((t) => t !== null);
-    }
-    static create(url, options) {
-        const m = options.rpcMount.startsWith("/") ?
-            options.rpcMount :
-            `/${options.rpcMount}`;
-        return new Client(url, m);
-    }
-    async login(token) {
-        this.setToken(token);
-        return true;
-    }
-    logout() {
-        this.setToken(null);
-    }
-    async exec(action, input, onError = {}) {
-        while (true) {
-            try {
-                return await this.unsafeExec(action, input);
-            }
-            catch (e) {
-                if (e instanceof ClientAuthError) {
-                    this.logout();
-                    await this.token.load();
-                    continue;
-                }
-                if (e instanceof ClientServerError) {
-                    const handler = onError[e.code];
-                    if (handler) {
-                        await handler(e.payload);
-                    }
-                }
-                throw e;
-            }
-        }
-    }
-    async unsafeExec(action, input) {
-        const testedToken = this.token.value;
-        const actionKey = action;
-        const wireBody = {
-            action: actionKey,
-            payload: input,
-        };
-        const res = await fetch(`${this.url}${this.rpcMount}`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/vnd.msgpack",
-                ...(testedToken !== null ? { Authorization: `Bearer ${testedToken}` } : {}),
-            },
-            body: new Uint8Array((0, msgpack_1.encode)(wireBody)),
-        });
-        const buf = await res.arrayBuffer();
-        const decoded = (0, msgpack_1.decode)(buf);
-        if (res.status === 200)
-            return decoded;
-        if (res.status === 422) {
-            const data = decoded;
-            throw new ClientValidationError(data.errors);
-        }
-        const genericError = decoded;
-        if (res.status === 400 || res.status === 404 || res.status === 500) {
-            throw new ClientServerError(genericError.code, genericError.error, genericError.payload ?? {});
-        }
-        if (res.status === 401 || res.status === 403) {
-            this.setToken(null);
-            throw new ClientAuthError(genericError.code, genericError.error, genericError.payload);
-        }
-        throw new ClientError(`Unexpected server response: ${res.status}`);
-    }
-}
-exports.Client = Client;
+// export type { AppserverData };
+// export type ClientCreateOptions = {
+//     rpcMount: string;
+// };
+// export class ClientError extends Error {
+//     constructor(message: string) {
+//         super(message);
+//     }
+// }
+// export class ClientAuthError extends ClientError {
+//     constructor(
+//         public readonly code: string = "PERMISSION_DENIED",
+//         message: string = "Permission denied",
+//         public readonly payload: AppserverData = {},
+//     ) {
+//         super(message);
+//     }
+// }
+// export class ClientServerError extends ClientError {
+//     constructor(public code: string, message: string, public payload: AppserverData = {}) {
+//         super(message);
+//     }
+// }
+// type ClientValidationErrorError = {
+//     path: string;
+//     message: string;
+//     value: unknown;
+// }
+// export class ClientValidationError extends ClientError {
+//     public readonly errors: ClientValidationErrorError[];
+//     constructor(errors: ClientValidationErrorError[]) {
+//         const first = errors[0] ?? {
+//             path: "Internal Error",
+//             message: "",
+//             value: undefined,
+//         };
+//         super(`[Validation Error] ${first.path}: ${first.message}`);
+//         this.errors = errors;
+//     }
+// }
+// export class Client {
+//     private readonly token: Whispr<string | null>;
+//     private readonly setToken: WhisprSetter<string | null>;
+//     public readonly loggedIn: Whispr<boolean>;
+//     private constructor(
+//         private url: string,
+//         private readonly rpcMount: string,
+//     ) {
+//         const [token, setToken] = Whispr.create<string | null>(''); // This will make sure the loggedin only flips to false when there is really an auth rejected. Server will ignore invalid tokens on public apis anyway
+//         this.token = token;
+//         this.setToken = setToken;
+//         this.loggedIn = token.transform((t) => t !== null);
+//     }
+//     public static create(url: string, options: ClientCreateOptions): Client {
+//         const m = options.rpcMount.startsWith("/") ?
+//             options.rpcMount :
+//             `/${options.rpcMount}`;
+//         return new Client(url, m);
+//     }
+//     public async login(token: string): Promise<boolean> {
+//         this.setToken(token);
+//         return true;
+//     }
+//     public logout(): void {
+//         this.setToken(null);
+//     }
+//     public async exec<I extends AppserverData, O extends AppserverData>(
+//         action: string,
+//         input: I,
+//         onError: Record<string, (payload: AppserverData) => Promise<void>> = {},
+//     ): Promise<O> {
+//         while (true) {
+//             try {
+//                 return await this.unsafeExec(action, input);
+//             } catch (e) {
+//                 if (e instanceof ClientAuthError) {
+//                     this.logout();
+//                     await this.token.load();
+//                     continue;
+//                 }
+//                 if (e instanceof ClientServerError) {
+//                     const handler = onError[e.code];
+//                     if (handler) {
+//                         await handler(e.payload);
+//                     }
+//                 }
+//                 throw e;
+//             }
+//         }
+//     }
+//     private async unsafeExec<I extends AppserverData, O extends AppserverData>(
+//         action: string,
+//         input: I,
+//     ): Promise<O> {
+//         const testedToken = this.token.value;
+//         const actionKey = action;
+//         const wireBody = {
+//             action: actionKey,
+//             payload: input as AppserverData,
+//         };
+//         const res = await fetch(`${this.url}${this.rpcMount}`, {
+//             method: "POST",
+//             headers: {
+//                 "Content-Type": "application/vnd.msgpack",
+//                 ...(testedToken !== null ? { Authorization: `Bearer ${testedToken}` } : {}),
+//             },
+//             body: new Uint8Array(encode(wireBody)),
+//         });
+//         const buf = await res.arrayBuffer();
+//         const decoded = decode(buf);
+//         if (res.status === 200)
+//             return decoded as O;
+//         if (res.status === 422) {
+//             const data = decoded as {
+//                 errors: ClientValidationErrorError[];
+//                 received: AppserverData;
+//             }
+//             throw new ClientValidationError(data.errors);
+//         }
+//         const genericError = decoded as {
+//             error: string;
+//             code: string;
+//             payload: AppserverData;
+//         }
+//         if (res.status === 400 || res.status === 404 || res.status === 500) {
+//             throw new ClientServerError(
+//                 genericError.code,
+//                 genericError.error,
+//                 genericError.payload ?? {},
+//             );
+//         }
+//         if (res.status === 401 || res.status === 403) {
+//             this.setToken(null);
+//             throw new ClientAuthError(
+//                 genericError.code,
+//                 genericError.error,
+//                 genericError.payload,
+//             )
+//         }
+//         throw new ClientError(`Unexpected server response: ${res.status}`);
+//     }
+// }

package/dist/Appserver/server.d.ts

@@ -1,31 +1,41 @@
-import { Static, TSchema } from '@sinclair/typebox';
-import express from 'express';
-import { AppserverData } from './common';
-export type { AppserverData };
-export { Static, TSchema, Type } from '@sinclair/typebox';
-export { Value } from '@sinclair/typebox/value';
-export { FormatRegistry } from '@sinclair/typebox';
-export type AppserverHandler<I extends AppserverData, O extends AppserverData> = (input: I, auth: string | undefined) => Promise<O> | O;
-declare class AppserverError<P extends AppserverData = AppserverData> extends Error {
-    code: string;
-    payload: P;
-    status: number;
-    constructor(code: string, message: string, payload?: P, status?: number);
+import { type Static, type TSchema, type TypeBoxTypeProvider, Type } from '@fastify/type-provider-typebox';
+export { Type };
+declare module 'fastify' {
+    interface FastifyRequest {
+        user: {
+            id: string;
+        } | null;
+    }
 }
-export declare class AppserverAuthError extends AppserverError {
-    constructor(message?: string, code?: string);
+export declare class Appserver {
+    readonly fastify: import("fastify").FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, TypeBoxTypeProvider>;
+    private readonly jwks;
+    private readonly issuer;
+    private readonly audience;
+    private static resolveAuth;
+    private readonly rpcBase;
+    private constructor();
+    static create(audience: string, issuerUrl: string, rpcBase?: string): Promise<Appserver>;
+    listen(port: number): Promise<void>;
+    registerRpc<TInput extends TSchema, TOutput extends TSchema>(route: string, schema: {
+        input: TInput;
+        output: TOutput;
+    }, scope: string, handler: (data: Static<TInput>, user: {
+        id: string;
+    }) => Promise<Static<TOutput>>): void;
+    private enforceAccess;
+    private handleError;
+    autoload(base: string): Promise<void>;
 }
-export declare class AppserverHandledError<P extends AppserverData = AppserverData> extends AppserverError<P> {
-    constructor(code: string, message: string, payload?: P);
+declare class AppserverHandledError<T extends TSchema = Record<string, never>> extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: T;
+    constructor(code: string, message: string, status: number, details: T);
 }
-export type AppserverModule<ISchema extends TSchema = TSchema, O extends AppserverData = AppserverData, I extends Static<ISchema> & AppserverData = Static<ISchema> & AppserverData> = {
-    schema: ISchema;
-    handler: AppserverHandler<I, O>;
-};
-export declare class AppserverDispatcher {
-    private registry;
-    register<ISchema extends TSchema, O extends AppserverData, I extends Static<ISchema> & AppserverData = Static<ISchema> & AppserverData>(action: string, mod: AppserverModule<ISchema, O, I>): void;
-    autoload(base: string): Promise<void>;
-    bind(app: express.Express, path: string): void;
-    private dispatch;
+export declare class AppserverAuthHandledError extends AppserverHandledError {
+    constructor(code: string, message: string, recoverable?: boolean);
+}
+export declare class AppserverUserHandledError<T extends TSchema = Record<string, never>> extends AppserverHandledError<T> {
+    constructor(code: string, message: string, details: T);
 }