@cripty2001/utils 0.0.243 → 0.0.245

package/dist/Appserver/server.js

@@ -3,49 +3,148 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppserverDispatcher = exports.AppserverHandledError = exports.AppserverAuthError = exports.FormatRegistry = exports.Value = exports.Type = void 0;
-const msgpack_1 = require("@msgpack/msgpack");
-const value_1 = require("@sinclair/typebox/value");
-const express_1 = __importDefault(require("express"));
-const promises_1 = require("fs/promises");
+exports.AppserverUserHandledError = exports.AppserverAuthHandledError = exports.Appserver = exports.Type = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const type_provider_typebox_1 = require("@fastify/type-provider-typebox");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return type_provider_typebox_1.Type; } });
 const path_1 = __importDefault(require("path"));
-// Helpful for avoiding sinclair version mismatch between this and the actual user of the package
-var typebox_1 = require("@sinclair/typebox");
-Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return typebox_1.Type; } });
-var value_2 = require("@sinclair/typebox/value");
-Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return value_2.Value; } });
-var typebox_2 = require("@sinclair/typebox");
-Object.defineProperty(exports, "FormatRegistry", { enumerable: true, get: function () { return typebox_2.FormatRegistry; } });
-(0, msgpack_1.encode)({}); // Fixes issue with msgpack not being included in build
-class AppserverError extends Error {
-    code;
-    payload;
-    status;
-    constructor(code, message, payload = {}, status = 500) {
-        super(message);
-        this.code = code;
-        this.payload = payload;
-        this.status = status;
+const promises_1 = require("fs/promises");
+const jose_1 = require("jose");
+class Appserver {
+    fastify = (0, fastify_1.default)({ logger: true })
+        .withTypeProvider();
+    jwks;
+    issuer;
+    audience;
+    static async resolveAuth(baseUrl) {
+        const res = await fetch(`${baseUrl}/.well-known/openid-configuration`);
+        if (!res.ok)
+            throw new Error(`OIDC discovery failed: ${res.status}`);
+        const config = await res.json();
+        if (!config?.jwks_uri)
+            throw new Error('OIDC discovery failed: jwks_uri not found');
+        if (!config.issuer)
+            throw new Error('OIDC discovery failed: issuer not found');
+        const jwksUrl = config.jwks_uri;
+        const issuer = config.issuer;
+        const jwks = (0, jose_1.createRemoteJWKSet)(new URL(jwksUrl));
+        return {
+            jwks,
+            issuer
+        };
     }
-}
-class AppserverAuthError extends AppserverError {
-    constructor(message = "You have no right to access this page", code = "PERMISSION_DENIED") {
-        super(code, message, {}, 403);
+    rpcBase;
+    constructor(rpcBase, jwks, issuer, audience) {
+        this.rpcBase = rpcBase;
+        this.jwks = jwks;
+        this.issuer = issuer;
+        this.audience = audience;
     }
-}
-exports.AppserverAuthError = AppserverAuthError;
-class AppserverHandledError extends AppserverError {
-    constructor(code, message, payload = {}) {
-        super(code, message, payload);
+    static async create(audience, issuerUrl, rpcBase = '/exec') {
+        const { jwks, issuer } = await this.resolveAuth(issuerUrl);
+        const appserver = new Appserver(rpcBase, jwks, issuer, audience);
+        appserver.fastify.setErrorHandler(appserver.handleError
+            .bind(appserver));
+        appserver.fastify.addContentTypeParser('application/octet-stream', { parseAs: 'buffer', bodyLimit: 64 * 1024 * 1024 }, (_req, body, done) => {
+            done(null, body);
+        });
+        appserver.fastify.decorateRequest('user', null);
+        return appserver;
     }
-}
-exports.AppserverHandledError = AppserverHandledError;
-class AppserverDispatcher {
-    registry = new Map();
-    register(action, mod) {
-        if (this.registry.has(action))
-            throw new Error(`Action already registered: "${action}"`);
-        this.registry.set(action, mod);
+    async listen(port) {
+        await this.fastify.listen({
+            port,
+            host: '0.0.0.0'
+        });
+    }
+    registerRpc(route, schema, scope, handler) {
+        const routeSchema = {
+            body: schema.input,
+            response: {
+                200: schema.output,
+            },
+        };
+        this.fastify.post(`${this.rpcBase}/${route.replace(/^\/+/, '')}`, {
+            preHandler: [
+                this.enforceAccess(scope)
+            ],
+            schema: routeSchema,
+        }, async (request) => {
+            const user = request.user;
+            return handler(request.body, user);
+        });
+    }
+    enforceAccess(scope) {
+        return async (request, _reply) => {
+            const token = request.headers.authorization;
+            if (!token || !token.startsWith('Bearer '))
+                throw new AppserverAuthHandledError('HEADER_MISSING', 'Missing or invalid authorization header', true);
+            const payload = await (async () => {
+                try {
+                    const { payload } = await (0, jose_1.jwtVerify)(token.slice(7), this.jwks, {
+                        issuer: this.issuer,
+                        audience: this.audience,
+                        requiredClaims: ['sub'],
+                    });
+                    return payload;
+                }
+                catch (err) {
+                    if (err instanceof jose_1.errors.JWTExpired)
+                        throw new AppserverAuthHandledError('TOKEN_EXPIRED', 'Access token has expired.', true);
+                    if (err instanceof jose_1.errors.JWTInvalid
+                        || err instanceof jose_1.errors.JWTClaimValidationFailed
+                        || err instanceof jose_1.errors.JWSSignatureVerificationFailed
+                        || err instanceof jose_1.errors.JWSInvalid
+                        || err instanceof jose_1.errors.JWKSNoMatchingKey
+                        || err instanceof jose_1.errors.JOSEAlgNotAllowed)
+                        throw new AppserverAuthHandledError('TOKEN_INVALID', 'Access token is invalid', true);
+                    if (err instanceof jose_1.errors.JWKSTimeout || err instanceof jose_1.errors.JWKSInvalid)
+                        throw new Error('Failed to verify the access token against the identity provider JWKS.', { cause: err });
+                    if (err instanceof Error)
+                        throw err;
+                    throw new Error('Unexpected failure while verifying the access token.', {
+                        cause: err
+                    });
+                }
+            })();
+            const scopes = payload.scope?.split(' ') ?? [];
+            if (!scopes.includes(`res:${scope}`))
+                throw new AppserverAuthHandledError('MISSING_SCOPE', 'Access token scope is not valid.', false);
+            if (!payload.sub)
+                throw new Error('JOSE assert failed, sub is missing despite being required');
+            request.user = {
+                id: payload.sub
+            };
+        };
+    }
+    handleError(error, request, reply) {
+        if (error.validation)
+            return reply
+                .code(422)
+                .send({
+                errors: error.validation,
+            });
+        if (error instanceof AppserverHandledError)
+            return reply
+                .status(error.status)
+                .send({
+                code: error.code,
+                message: error.message,
+                details: error.details,
+            });
+        request.log.error({
+            error: {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            }
+        }, 'unhandled error');
+        reply
+            .status(500)
+            .send({
+            code: 'INTERNAL_ERROR',
+            message: 'Internal server error',
+        });
     }
     async autoload(base) {
         const absBase = path_1.default.resolve(base);
@@ -53,7 +152,8 @@ class AppserverDispatcher {
             recursive: true,
             withFileTypes: true
         });
-        const jsFiles = files.filter(e => e.isFile() && e.name.endsWith('.js'));
+        const jsFiles = files
+            .filter(e => e.isFile() && e.name.endsWith('.js'));
         if (jsFiles.length === 0) {
             console.warn(`[appserver] autoload found no .js files in "${absBase}".`, `If you are using TypeScript, make sure the api directory is included in your tsconfig`, `and that you are pointing autoload at the compiled output directory, not the source.`);
             return;
@@ -69,70 +169,33 @@ class AppserverDispatcher {
             if (!ACTION_REGEX.test(action))
                 throw new Error(`Invalid module path "${action}" — all segments must be lowercase alphanumeric`);
             const mod = await import(fullPath);
-            if (!mod.default || typeof mod.default.handler !== 'function' || !mod.default.schema)
-                throw new Error(`Module "${fullPath}" must have a default export satisfying ApiModule`);
-            this.register(action, mod.default);
+            if (!mod.default)
+                throw new Error(`Module "${fullPath}" must have a default export containing a registering function (register(app: Appserver) => void)`);
+            mod.default(this, action);
         }
     }
-    bind(app, path) {
-        app.post(path, express_1.default.raw({
-            type: 'application/vnd.msgpack',
-            limit: '2gb'
-        }), async (req, res) => {
-            await this.dispatch(req, res);
-        });
+}
+exports.Appserver = Appserver;
+class AppserverHandledError extends Error {
+    status;
+    code;
+    details;
+    constructor(code, message, status, details) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.details = details;
     }
-    async dispatch(req, res) {
-        const respond = (status, data) => {
-            res
-                .status(status)
-                .send((0, msgpack_1.encode)(data));
-        };
-        try {
-            if (req.headers['content-type'] !== 'application/vnd.msgpack')
-                throw new AppserverError('REQUEST_INVALID_TYPE_HEADER', 'Content-Type must be a messagepack (application/vnd.msgpack)', {}, 400);
-            const parsed = (() => {
-                try {
-                    return (0, msgpack_1.decode)(req.body);
-                }
-                catch (e) {
-                    throw new AppserverError('REQUEST_INVALID_BODY', 'Request body is not valid msgpack', {}, 400);
-                }
-            })();
-            const { action, payload } = parsed;
-            if (typeof action !== 'string')
-                throw new AppserverError("REQUEST_INVALID_ACTION", "Missing action field", {}, 400);
-            const mod = this.registry.get(action);
-            if (mod === undefined)
-                throw new AppserverError("ACTION_NOT_FOUND", `Action not found: ${action}`, {}, 404);
-            const token = req.headers['authorization']?.startsWith('Bearer ') ?
-                req.headers['authorization'].slice(7) :
-                undefined;
-            if (!value_1.Value.Check(mod.schema, payload))
-                return respond(422, {
-                    errors: [...value_1.Value.Errors(mod.schema, payload)]
-                        .map(e => ({
-                        path: e.path,
-                        message: e.message,
-                        value: e.value,
-                    })),
-                    received: payload,
-                });
-            return respond(200, await mod.handler(payload, token));
-        }
-        catch (e) {
-            if (e instanceof AppserverError)
-                return respond(e.status, {
-                    error: e.message,
-                    code: e.code,
-                    payload: e.payload
-                });
-            console.error("Unhandled server error:", e);
-            return respond(500, {
-                error: 'Internal server error',
-                code: 'INTERNAL_SERVERERROR'
-            });
-        }
+}
+class AppserverAuthHandledError extends AppserverHandledError {
+    constructor(code, message, recoverable = false) {
+        super(code, message, recoverable ? 401 : 403, {});
+    }
+}
+exports.AppserverAuthHandledError = AppserverAuthHandledError;
+class AppserverUserHandledError extends AppserverHandledError {
+    constructor(code, message, details) {
+        super(code, message, 400, details ?? {});
     }
 }
-exports.AppserverDispatcher = AppserverDispatcher;
+exports.AppserverUserHandledError = AppserverUserHandledError;

package/dist/index.d.ts

@@ -44,7 +44,7 @@ export declare function getRandomOtp(length?: number, char?: boolean): string;
  * @param ms The number of milliseconds to sleep
  */
 export declare function sleep(ms: number): Promise<void>;
-export declare function parseHash(fields: string[]): URLSearchParams;
+export declare function parseHash(fields: string[], deleteFields?: boolean): URLSearchParams;
 /**
  * Start an infinite loop executing an async callback spaced by at least the given interval.
  * The loop ignores errors (the next execution is not affected), but an optional error callback can be provided to handle them.

package/dist/index.js

@@ -96,7 +96,7 @@ function getRandomOtp(length = 6, char = false) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function parseHash(fields) {
+function parseHash(fields, deleteFields = false) {
     // Checking empty hash
     if (window.location.hash === "")
         return new URLSearchParams();
@@ -107,7 +107,9 @@ function parseHash(fields) {
     for (const field of fields) {
         if (data.has(field)) {
             toReturn.set(field, data.get(field));
-            data.delete(field);
+            if (deleteFields) {
+                data.delete(field);
+            }
         }
     }
     // Reencoding hash without extracted fields

package/dist/react-ui/loader.d.ts

@@ -6,5 +6,6 @@ export type LoaderProps<T> = {
         data: T;
     }) => React.ReactNode;
     loader?: React.ReactNode;
+    showRefreshing?: boolean;
 };
 export default function Loader<T>(props: LoaderProps<T>): React.JSX.Element;

package/dist/react-ui/loader.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = Loader;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_whispr_1 = require("../react-whispr");
+const react_1 = require("react");
 const spinKeyframes = `
 @keyframes spin {
     from { transform: rotate(0deg); }
@@ -18,7 +19,18 @@ if (typeof document !== 'undefined') {
     }
 }
 function Loader(props) {
-    const data = (0, react_whispr_1.useWhisprValue)(props.data.data);
+    const prev = (0, react_1.useRef)({ loading: true, progress: 0 });
+    const state = (0, react_whispr_1.useWhisprValue)(props.data.data);
+    (0, react_1.useEffect)(() => {
+        prev.current = state;
+    }, [state]);
+    const data = (0, react_1.useMemo)(() => {
+        if (props.showRefreshing)
+            return state;
+        if (state.loading && prev.current !== null)
+            return prev.current;
+        return state;
+    }, [state.loading, prev.current, props.showRefreshing]);
     return ((0, jsx_runtime_1.jsx)("div", { children: (0, jsx_runtime_1.jsx)(Content, { data: data, children: props.children, loader: props.loader }) }));
 }
 function Content({ data, children, loader }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cripty2001/utils",
-  "version": "0.0.243",
+  "version": "0.0.245",
   "description": "Internal Set of utils. If you need them use them, otherwise go to the next package ;)",
   "homepage": "https://github.com/cripty2001/utils#readme",
   "bugs": {
@@ -31,12 +31,9 @@
   "dependencies": {
     "@cripty2001/whispr": "^0.4.1",
     "@sinclair/typebox": "^0.34.41",
-    "cors": "^2.8.6",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.5",
     "@types/lodash": "^4.17.21",
     "@types/node": "^24.13.3",
     "@types/react": "^19",
@@ -44,9 +41,10 @@
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "@msgpack/msgpack": "^3.1.2",
+    "@fastify/type-provider-typebox": "^6.1.0",
     "dotenv": "^17.2.3",
-    "express": "^5.2.1",
+    "fastify": "^5.12.5",
+    "jose": "^6.2.12",
     "lucide-react": ">=0.552.0",
     "react": "^19"
   },
@@ -96,11 +94,6 @@
       "types": "./dist/Appserver/server.d.ts",
       "require": "./dist/Appserver/server.js"
     },
-    "./appserver/client": {
-      "import": "./dist/Appserver/client.js",
-      "types": "./dist/Appserver/client.d.ts",
-      "require": "./dist/Appserver/client.js"
-    },
     "./react": {
       "import": "./dist/react/index.js",
       "types": "./dist/react/index.d.ts",