@cripty2001/utils 0.0.259 → 0.0.261

package/dist/Appserver/client/react.d.ts

@@ -0,0 +1,52 @@
+import { type ReactNode } from "react";
+type LoginSheetPropsConfig = {
+    issuer: string;
+    clientId: string;
+    scopes: string[];
+    apiUrl: string;
+};
+type LoginSheetProps = {
+    children: ReactNode;
+    templates: {
+        Loading: ({ message }: {
+            message: string;
+        }) => ReactNode;
+        Error: ({ message, callback }: {
+            message: string;
+            callback: () => Promise<void>;
+        }) => ReactNode;
+    };
+    config: LoginSheetPropsConfig;
+};
+export default function ApiProvider({ children, config, templates }: LoginSheetProps): import("react").JSX.Element;
+export type AppserverData = number | string | boolean | AppserverData[] | null | {
+    [key: string]: AppserverData;
+};
+export type ExecOnError = Record<string, (payload: AppserverData) => Promise<void>>;
+export type Exec = <I extends AppserverData, O extends AppserverData>(action: string, data: I, onError?: ExecOnError) => Promise<O>;
+type ApiContextValue = {
+    exec: Exec;
+    logout: (remote: boolean) => Promise<void>;
+    profile: Record<string, unknown> | undefined;
+};
+export declare class ApiError extends Error {
+}
+export declare class AuthApiError extends ApiError {
+    readonly recoverable: boolean;
+    constructor(recoverable: boolean);
+}
+export declare class ValidationApiError extends ApiError {
+    data: AppserverData;
+    constructor(data: AppserverData);
+}
+export declare class ClientApiError extends ApiError {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: AppserverData;
+    constructor(code: string, message: string, details?: AppserverData);
+}
+export declare class UnknownApiError extends ApiError {
+    constructor();
+}
+export declare function useApi(): ApiContextValue;
+export {};

package/dist/Appserver/client/react.js

@@ -0,0 +1,143 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, createContext, useContext, useMemo, } from "react";
+import { AuthProvider, useAuth } from "react-oidc-context";
+export default function ApiProvider({ children, config, templates }) {
+    const oidcConfig = {
+        authority: config.issuer,
+        client_id: config.clientId,
+        redirect_uri: `${window.location.origin}/`,
+        scope: [
+            "openid", "offline_access",
+            ...config.scopes
+        ].join(" "),
+        extraQueryParams: {},
+        extraTokenParams: { resource: config.apiUrl },
+        onSigninCallback: (user) => {
+            const state = user?.state;
+            window.location.replace(state?.returnTo ?? "/");
+        },
+    };
+    return (_jsx(AuthProvider, { ...oidcConfig, children: _jsx(_ApiProvider, { apiUrl: config.apiUrl, children: _jsx(_LoginSheet, { config: config, templates: templates, children: children }) }) }));
+}
+function _LoginSheet({ children, config, templates }) {
+    const auth = useAuth();
+    const login = useCallback(async () => {
+        sessionStorage.setItem("auth_redirect_url", window.location.href);
+        const state = {
+            returnTo: window.location.href
+        };
+        await auth.signinRedirect({
+            extraQueryParams: {
+                prompt: "consent",
+                resource: config.apiUrl
+            },
+            state
+        });
+    }, [auth]);
+    useEffect(() => {
+        if (auth.isLoading)
+            return;
+        if (auth.isAuthenticated && auth.user)
+            return;
+        if (auth.error)
+            return;
+        login();
+    }, [auth, login]);
+    if (auth.isLoading)
+        return _jsx(templates.Loading, { message: "Restoring your session..." });
+    if (auth.isAuthenticated && auth.user)
+        return _jsx(_Fragment, { children: children });
+    return _jsx(templates.Error, { message: auth.error?.message ?? "An error occurred while restoring your session.", callback: login });
+}
+const ApiContext = createContext(null);
+export class ApiError extends Error {
+}
+export class AuthApiError extends ApiError {
+    recoverable;
+    constructor(recoverable) {
+        super(recoverable ?
+            "Authentication required" :
+            "Permission denied");
+        this.recoverable = recoverable;
+    }
+}
+export class ValidationApiError extends ApiError {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+}
+export class ClientApiError extends ApiError {
+    code;
+    message;
+    details;
+    constructor(code, message, details) {
+        super();
+        this.code = code;
+        this.message = message;
+        this.details = details;
+    }
+}
+export class UnknownApiError extends ApiError {
+    constructor() {
+        super();
+        this.message = "An unknown error occurred";
+    }
+}
+function _ApiProvider({ children, apiUrl }) {
+    const auth = useAuth();
+    const profile = useMemo(() => {
+        if (!auth.user)
+            return undefined;
+        return auth.user.profile;
+    }, [auth]);
+    const logout = useCallback(async (remote = false) => {
+        if (remote) {
+            await auth.signoutRedirect();
+        }
+        else {
+            auth.removeUser();
+        }
+    }, [auth]);
+    const exec = useCallback(async (action, data, onError) => {
+        const res = await fetch(`${apiUrl}/exec/${action.startsWith('/') ? action.slice(1) : action}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${auth.user?.access_token}`,
+            },
+            body: JSON.stringify(data)
+        });
+        if (res.status === 401) {
+            auth.removeUser();
+            throw new AuthApiError(true);
+        }
+        if (res.status === 403) {
+            throw new AuthApiError(false);
+        }
+        if (res.status === 422) {
+            const body = await res.json();
+            throw new ValidationApiError(body);
+        }
+        if (res.status === 400) {
+            const body = await res.json();
+            const handler = onError?.[body.code];
+            if (handler)
+                await handler(body.details ?? {});
+            throw new ClientApiError(body.code, body.message, body.details);
+        }
+        if (res.status === 200) {
+            const body = await res.json();
+            return body;
+        }
+        throw new UnknownApiError();
+    }, [auth]);
+    return _jsxs(ApiContext.Provider, { value: { exec, logout, profile }, children: [" ", children, " "] });
+}
+export function useApi() {
+    const ctx = useContext(ApiContext);
+    if (!ctx)
+        throw new Error("useApi must be used within ApiProvider");
+    return ctx;
+}

package/dist/Appserver/server.d.ts

@@ -1,3 +1,4 @@
+import Fastify from 'fastify';
 import { type Static, type TSchema, type TypeBoxTypeProvider, Type } from '@fastify/type-provider-typebox';
 export { Type };
 declare module 'fastify' {
@@ -8,14 +9,15 @@ declare module 'fastify' {
     }
 }
 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>;
+    readonly fastify: Fastify.FastifyInstance<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, Fastify.FastifyBaseLogger, TypeBoxTypeProvider>;
     private readonly jwks;
     private readonly issuer;
     private readonly audience;
+    private readonly scopesKey;
     private static resolveAuth;
     private readonly rpcBase;
     private constructor();
-    static create(audience: string, issuerUrl: string, rpcBase?: string): Promise<Appserver>;
+    static create(audience: string, issuerUrl: string, rpcBase?: string, scopesKey?: string): Promise<Appserver>;
     listen(port: number): Promise<void>;
     registerRpc<TInput extends TSchema, TOutput extends TSchema>(route: string, schema: {
         input: TInput;

package/dist/Appserver/server.js

@@ -1,21 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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"));
-const promises_1 = require("fs/promises");
-const jose_1 = require("jose");
-class Appserver {
-    fastify = (0, fastify_1.default)({ logger: true })
+import Fastify from 'fastify';
+import { Type } from '@fastify/type-provider-typebox';
+import path from 'path';
+import { readdir } from 'fs/promises';
+import { createRemoteJWKSet, errors, jwtVerify } from 'jose';
+export { Type };
+export class Appserver {
+    fastify = Fastify({ logger: true })
         .withTypeProvider();
     jwks;
     issuer;
     audience;
+    scopesKey;
     static async resolveAuth(baseUrl) {
         const res = await fetch(`${baseUrl}/.well-known/openid-configuration`);
         if (!res.ok)
@@ -27,22 +22,23 @@ class Appserver {
             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));
+        const jwks = createRemoteJWKSet(new URL(jwksUrl));
         return {
             jwks,
             issuer
         };
     }
     rpcBase;
-    constructor(rpcBase, jwks, issuer, audience) {
+    constructor(rpcBase, jwks, issuer, audience, scopesKey) {
         this.rpcBase = rpcBase;
         this.jwks = jwks;
         this.issuer = issuer;
         this.audience = audience;
+        this.scopesKey = scopesKey;
     }
-    static async create(audience, issuerUrl, rpcBase = '/exec') {
+    static async create(audience, issuerUrl, rpcBase = '/exec', scopesKey = 'scope') {
         const { jwks, issuer } = await this.resolveAuth(issuerUrl);
-        const appserver = new Appserver(rpcBase, jwks, issuer, audience);
+        const appserver = new Appserver(rpcBase, jwks, issuer, audience, scopesKey);
         appserver.fastify.setErrorHandler(appserver.handleError
             .bind(appserver));
         appserver.fastify.addContentTypeParser('application/octet-stream', { parseAs: 'buffer', bodyLimit: 64 * 1024 * 1024 }, (_req, body, done) => {
@@ -81,24 +77,24 @@ class Appserver {
                 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, {
+                    const { payload } = await jwtVerify(token.slice(7), this.jwks, {
                         issuer: this.issuer,
                         audience: this.audience,
-                        requiredClaims: ['sub'],
+                        requiredClaims: ['sub', 'iat', 'exp'],
                     });
                     return payload;
                 }
                 catch (err) {
-                    if (err instanceof jose_1.errors.JWTExpired)
+                    if (err instanceof 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)
+                    if (err instanceof errors.JWTInvalid
+                        || err instanceof errors.JWTClaimValidationFailed
+                        || err instanceof errors.JWSSignatureVerificationFailed
+                        || err instanceof errors.JWSInvalid
+                        || err instanceof errors.JWKSNoMatchingKey
+                        || err instanceof 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)
+                    if (err instanceof errors.JWKSTimeout || err instanceof errors.JWKSInvalid)
                         throw new Error('Failed to verify the access token against the identity provider JWKS.', { cause: err });
                     if (err instanceof Error)
                         throw err;
@@ -107,8 +103,15 @@ class Appserver {
                     });
                 }
             })();
-            const scopes = payload.scope?.split(' ') ?? [];
-            if (!scopes.includes(`res:${scope}`))
+            const scopes = (() => {
+                const data = payload[this.scopesKey];
+                if (typeof data === 'string')
+                    return data.split(' ');
+                if (Array.isArray(data))
+                    return data;
+                return [];
+            })();
+            if (!scopes.includes(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');
@@ -147,8 +150,8 @@ class Appserver {
         });
     }
     async autoload(base) {
-        const absBase = path_1.default.resolve(base);
-        const files = await (0, promises_1.readdir)(absBase, {
+        const absBase = path.resolve(base);
+        const files = await readdir(absBase, {
             recursive: true,
             withFileTypes: true
         });
@@ -159,11 +162,11 @@ class Appserver {
             return;
         }
         for (const entry of jsFiles) {
-            const fullPath = path_1.default.join(entry.parentPath, entry.name);
-            const action = path_1.default
+            const fullPath = path.join(entry.parentPath, entry.name);
+            const action = path
                 .relative(absBase, fullPath)
                 .replace(/\.js$/, '')
-                .split(path_1.default.sep)
+                .split(path.sep)
                 .join('/');
             const ACTION_REGEX = /^([a-z0-9]+\/)*[a-z0-9]+$/;
             if (!ACTION_REGEX.test(action))
@@ -175,7 +178,6 @@ class Appserver {
         }
     }
 }
-exports.Appserver = Appserver;
 class AppserverHandledError extends Error {
     status;
     code;
@@ -187,15 +189,13 @@ class AppserverHandledError extends Error {
         this.details = details;
     }
 }
-class AppserverAuthHandledError extends AppserverHandledError {
+export class AppserverAuthHandledError extends AppserverHandledError {
     constructor(code, message, recoverable = false) {
         super(code, message, recoverable ? 401 : 403, {});
     }
 }
-exports.AppserverAuthHandledError = AppserverAuthHandledError;
-class AppserverUserHandledError extends AppserverHandledError {
+export class AppserverUserHandledError extends AppserverHandledError {
     constructor(code, message, details) {
         super(code, message, 400, details ?? {});
     }
 }
-exports.AppserverUserHandledError = AppserverUserHandledError;

package/dist/Appstorage.d.ts

@@ -1,5 +1,5 @@
 import { Whispr } from '@cripty2001/whispr';
-import { JSONEncodable } from './index';
+import { JSONEncodable } from './index.js';
 export type AppstorageData = Record<string, JSONEncodable>;
 export type AppstorageItemData<T extends AppstorageData> = {
     key: string;

package/dist/Appstorage.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Appstorage = void 0;
-const whispr_1 = require("@cripty2001/whispr");
-const Dispatcher_1 = require("./Dispatcher");
-class Appstorage {
+import { Whispr } from '@cripty2001/whispr';
+import { Dispatcher } from './Dispatcher.js';
+export class Appstorage {
     static instances = new Map();
     static getInstance(key) {
         if (!this.instances.has(key))
@@ -18,7 +15,7 @@ class Appstorage {
     }, 200);
     constructor(PREFIX) {
         this.PREFIX = PREFIX;
-        [this.index, this._setIndex] = whispr_1.Whispr.create({});
+        [this.index, this._setIndex] = Whispr.create({});
         this.refresh();
     }
     add(key, data) {
@@ -76,7 +73,6 @@ class Appstorage {
         });
     }
 }
-exports.Appstorage = Appstorage;
 class AppstorageItem {
     PREFIX;
     static instances = new Map();
@@ -101,7 +97,7 @@ class AppstorageItem {
     constructor(PREFIX, key) {
         this.PREFIX = PREFIX;
         this.key = key;
-        [this.data, this._setData] = whispr_1.Whispr.create(this.loadData());
+        [this.data, this._setData] = Whispr.create(this.loadData());
         this.update = (data) => {
             this._setData({
                 key: `${this.PREFIX}${this.key}`,
@@ -118,7 +114,7 @@ class AppstorageItem {
                 data: {}
             });
         };
-        new Dispatcher_1.Dispatcher(this.data, async () => {
+        new Dispatcher(this.data, async () => {
             this.flush();
         }, 500);
     }

package/dist/Dispatcher.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dispatcher = void 0;
-const whispr_1 = require("@cripty2001/whispr");
-const lodash_1 = require("lodash");
-const _1 = require(".");
-class Dispatcher {
+import { Whispr } from "@cripty2001/whispr";
+import { isEqual } from "lodash";
+import { sleep } from "./index.js";
+export class Dispatcher {
     state;
     setState;
     data;
@@ -21,7 +18,7 @@ class Dispatcher {
         this.f = f;
         this.DEBOUNCE_INTERVAL = DEBOUNCE_INTERVAL;
         this.value = value;
-        [this.state, this.setState] = whispr_1.Whispr.create({
+        [this.state, this.setState] = Whispr.create({
             controller: new AbortController(),
             payload: {
                 input: value.value,
@@ -33,15 +30,15 @@ class Dispatcher {
         });
         // Subscribing to input changes
         this.value.subscribe((v) => {
-            if (this.lastValue !== null && (0, lodash_1.isEqual)(this.lastValue, v))
+            if (this.lastValue !== null && isEqual(this.lastValue, v))
                 return;
             this.lastValue = v;
             this.dispatch(v);
         });
         // Initing public derived whisprs
-        this.data = whispr_1.Whispr
+        this.data = Whispr
             .from({ state: this.state }, ({ state }) => state.payload);
-        this.filtered = whispr_1.Whispr.from({
+        this.filtered = Whispr.from({
             data: this.data
         }, ({ data: { output: response } }) => {
             if (response.loading)
@@ -136,7 +133,7 @@ class Dispatcher {
         const toReturn = (async () => {
             // Allow for sync operations
             if (this.DEBOUNCE_INTERVAL > 0) {
-                await (0, _1.sleep)(this.DEBOUNCE_INTERVAL);
+                await sleep(this.DEBOUNCE_INTERVAL);
             }
             if (signals.controller.signal.aborted)
                 throw new DOMException('Debounced', 'AbortError');
@@ -152,4 +149,3 @@ class Dispatcher {
         return toReturn;
     }
 }
-exports.Dispatcher = Dispatcher;

package/dist/Logger/Logger.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const whispr_1 = require("@cripty2001/whispr");
-const __1 = require("..");
+import { Whispr } from "@cripty2001/whispr";
+import { getRandomId } from "../index.js";
 const AUTO_DISMISS_MS = {
     success: 5000,
     info: 5000,
@@ -15,7 +13,7 @@ class Logger {
     setLines;
     dismissTimers = new Map();
     constructor() {
-        [this.lines, this.setLines] = whispr_1.Whispr.create([]);
+        [this.lines, this.setLines] = Whispr.create([]);
         if (typeof window !== "undefined") {
             window.addEventListener("unhandledrejection", (e) => this.log(e.reason, "error"));
             window.addEventListener("error", (e) => this.logError(this.reconstructError(e)));
@@ -51,7 +49,7 @@ class Logger {
         this.setLines(this.lines.value.filter((i) => i.id !== id));
     }
     log(message, severity = "info", context) {
-        const id = (0, __1.getRandomId)();
+        const id = getRandomId();
         const item = {
             id,
             date: new Date(),
@@ -76,4 +74,4 @@ class Logger {
         return this.log("Unknown error - See Console", "error");
     }
 }
-exports.default = Logger.getInstance();
+export default Logger.getInstance();

package/dist/Searcher/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Searcher = void 0;
-class Searcher {
+export class Searcher {
     data = [];
     constructor(data) {
         this.data = data;
@@ -20,7 +17,6 @@ class Searcher {
         }));
     }
 }
-exports.Searcher = Searcher;
 // export function useSearcher_w<T>(data: Whispr<SearcherData<T>[]>, query: Whispr<string>): Whispr<SearcherData<T>[]> {
 //     const searcher = new Searcher<T>(data.value);
 //     let unsubscribe_q: () => void = () => { }