@bshsolutions/sdk-beta 0.0.2-beta

package/dist/types-lV042-cm.d.ts

@@ -0,0 +1,286 @@
+import { BshEntities, BshSchemas, BshTypes, BshUser, BshPolicy, BshRole, BshFiles, BshConfigurations, SentEmail, BshEmailTemplate, BshEventLogs, BshTrigger, BshTriggerInstance, BshResponse, BshSearch, LoginParams, AuthTokens, BshUserInit, BshSettings, UploadOptions, UploadResponse, MailingPayload, BshTriggerPlugin, BshTriggerAction, CacheInfo, BshApiKeysForm, BshApiKeys, BshError } from './types/index.js';
+
+declare class BshEngine {
+    private host?;
+    private clientFn;
+    private authFn?;
+    private refreshTokenFn?;
+    private postInterceptors;
+    private preInterceptors;
+    private errorInterceptors;
+    withHost(hostFn: string): this;
+    withClient(clientFn: BshClientFn): this;
+    withAuth(authFn: BshAuthFn): this;
+    withRefreshToken(refreshTokenFn: BshRefreshTokenFn): this;
+    postInterceptor(interceptor: BshPostInterceptor<unknown>): this;
+    preInterceptor(interceptor: BshPreInterceptor<unknown>): this;
+    errorInterceptor(interceptor: BshErrorInterceptor<unknown>): this;
+    getPostInterceptors(): BshPostInterceptor<unknown>[];
+    getPreInterceptors(): BshPreInterceptor<unknown>[];
+    getErrorInterceptors(): BshErrorInterceptor<unknown>[];
+    private get client();
+    get entities(): EntityService<unknown>;
+    entity<T>(entity: string): EntityService<T>;
+    get core(): {
+        BshEntities: EntityService<BshEntities>;
+        BshSchemas: EntityService<BshSchemas>;
+        BshTypes: EntityService<BshTypes>;
+        BshUsers: EntityService<BshUser>;
+        BshPolicies: EntityService<BshPolicy>;
+        BshRoles: EntityService<BshRole>;
+        BshFiles: EntityService<BshFiles>;
+        BshConfigurations: EntityService<BshConfigurations>;
+        BshEmails: EntityService<SentEmail>;
+        BshEmailTemplates: EntityService<BshEmailTemplate>;
+        BshEventLogs: EntityService<BshEventLogs>;
+        BshTriggers: EntityService<BshTrigger>;
+        BshTriggerInstances: EntityService<BshTriggerInstance>;
+    };
+    get auth(): AuthService;
+    get user(): UserService;
+    get settings(): SettingsService;
+    get image(): ImageService;
+    get mailing(): MailingService;
+    get utils(): BshUtilsService;
+    get caching(): CachingService;
+    get apiKey(): ApiKeyService;
+}
+
+declare class BshClient {
+    private readonly httpClient;
+    private readonly authFn?;
+    private readonly refreshTokenFn?;
+    private readonly host;
+    private readonly bshEngine?;
+    constructor(host?: string, httpClient?: BshClientFn, authFn?: BshAuthFn, refreshTokenFn?: BshRefreshTokenFn, bshEngine?: BshEngine);
+    private handleResponse;
+    private refreshTokenIfNeeded;
+    private getAuthHeaders;
+    get<T = unknown>(params: BshClientFnParams<T>): Promise<BshResponse<T> | undefined>;
+    post<T = unknown, R = T>(params: BshClientFnParams<T, R>): Promise<BshResponse<R> | undefined>;
+    put<T = unknown>(params: BshClientFnParams<T>): Promise<BshResponse<T> | undefined>;
+    delete<T = unknown>(params: BshClientFnParams<T>): Promise<BshResponse<T> | undefined>;
+    patch<T = unknown>(params: BshClientFnParams<T>): Promise<BshResponse<T> | undefined>;
+    download<T = unknown>(params: BshClientFnParams<T>): Promise<Blob | undefined>;
+}
+
+type EntityFnParams<T = unknown, R = T> = BshCallbackParams<T, R> & {
+    entity?: string;
+};
+type EntityFnParamsWithPayload<T = unknown, R = T> = BshCallbackParamsWithPayload<T, R> & {
+    entity?: string;
+};
+type EntitySearchFnParams<T, R = T> = EntityFnParamsWithPayload<BshSearch<T>, R>;
+declare class EntityService<T = unknown> {
+    private readonly client;
+    private readonly entity?;
+    private readonly baseEndpoint;
+    constructor(client: BshClient, entity?: string | undefined);
+    findById<TT = T>(params: EntityFnParams<TT> & {
+        id: string;
+    }): Promise<BshResponse<TT> | undefined>;
+    create<TT = T>(params: EntityFnParamsWithPayload<TT>): Promise<BshResponse<TT> | undefined>;
+    createMany<TT = T>(params: EntityFnParamsWithPayload<TT[], TT>): Promise<BshResponse<TT> | undefined>;
+    update<TT = T>(params: EntityFnParamsWithPayload<TT>): Promise<BshResponse<TT> | undefined>;
+    updateMany<TT = T>(params: EntityFnParamsWithPayload<TT[], TT>): Promise<BshResponse<TT> | undefined>;
+    search<TT extends T = T, R = TT>(params: EntitySearchFnParams<TT, R>): Promise<BshResponse<R> | undefined>;
+    delete<TT = T>(params: EntitySearchFnParams<TT, {
+        effected: number;
+    }>): Promise<BshResponse<{
+        effected: number;
+    }> | undefined>;
+    deleteById<TT = T>(params: EntityFnParams<TT, {
+        effected: number;
+    }> & {
+        id: string;
+    }): Promise<BshResponse<{
+        effected: number;
+    }> | undefined>;
+    columns(params: EntityFnParams<unknown, {
+        name: string;
+        type: string;
+    }>): Promise<BshResponse<{
+        name: string;
+        type: string;
+    }> | undefined>;
+    export<TT = T>(params: EntityFnParamsWithPayload<BshSearch<TT>, Blob> & {
+        format: 'csv' | 'json' | 'excel';
+        filename?: string;
+    }): Promise<void>;
+}
+
+declare class AuthService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    login(params: BshCallbackParamsWithPayload<LoginParams, AuthTokens>): Promise<BshResponse<AuthTokens> | undefined>;
+    register(params: BshCallbackParamsWithPayload<BshUserInit, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    refreshToken(params: BshCallbackParamsWithPayload<{
+        refresh: string;
+    }, AuthTokens>): Promise<BshResponse<AuthTokens> | undefined>;
+    forgetPassword(params: BshCallbackParamsWithPayload<{
+        email: string;
+    }, unknown>): Promise<BshResponse<unknown> | undefined>;
+    resetPassword(params: BshCallbackParamsWithPayload<{
+        email: string;
+        code: string;
+        newPassword: string;
+    }, unknown>): Promise<BshResponse<unknown> | undefined>;
+    activateAccount(params: BshCallbackParamsWithPayload<{
+        email: string;
+        code: string;
+    }, unknown>): Promise<BshResponse<unknown> | undefined>;
+}
+
+declare class UserService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    me(params: BshCallbackParams<unknown, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    init(params: BshCallbackParamsWithPayload<BshUserInit, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    updateProfile(params: BshCallbackParamsWithPayload<Partial<BshUser['profile']>, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    updatePicture(params: BshCallbackParamsWithPayload<File, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    updatePassword(params: BshCallbackParamsWithPayload<{
+        currentPassword: string;
+        newPassword: string;
+    }, {
+        message: string;
+    }>): Promise<BshResponse<{
+        message: string;
+    }> | undefined>;
+    getById(params: BshCallbackParams<unknown, BshUser> & {
+        id: string;
+    }): Promise<BshResponse<BshUser> | undefined>;
+    search(params: BshCallbackParamsWithPayload<BshSearch<BshUser> | undefined, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    list(params: BshCallbackParams<unknown, BshUser> & {
+        queryParams?: {
+            page?: string;
+            size?: string;
+            sort?: string;
+            filter?: string;
+        };
+    }): Promise<BshResponse<BshUser> | undefined>;
+    update(params: BshCallbackParamsWithPayload<Partial<BshUser>, BshUser>): Promise<BshResponse<BshUser> | undefined>;
+    deleteById(params: BshCallbackParams<unknown, BshUser> & {
+        id: string;
+    }): Promise<BshResponse<BshUser> | undefined>;
+}
+
+declare class SettingsService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    load(params: BshCallbackParams<unknown, BshSettings>): Promise<BshResponse<BshSettings> | undefined>;
+    update(params: BshCallbackParamsWithPayload<BshSettings, BshSettings>): Promise<BshResponse<BshSettings> | undefined>;
+}
+
+declare class ImageService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    upload(params: BshCallbackParamsWithPayload<{
+        file: File;
+        namespace?: string;
+        assetId?: string;
+        options?: UploadOptions;
+    }, UploadResponse>): Promise<BshResponse<UploadResponse> | undefined>;
+}
+
+declare class MailingService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    send(params: BshCallbackParamsWithPayload<MailingPayload, MailingPayload>): Promise<BshResponse<MailingPayload> | undefined>;
+}
+
+declare class BshUtilsService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    triggerPlugins(params: BshCallbackParams<unknown, BshTriggerPlugin>): Promise<BshResponse<BshTriggerPlugin> | undefined>;
+    triggerActions(params: BshCallbackParams<unknown, BshTriggerAction>): Promise<BshResponse<BshTriggerAction> | undefined>;
+}
+
+type CacheRemoveResponse = {
+    caches: string[];
+};
+declare class CachingService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    findById(params: BshCallbackParams<unknown, CacheInfo> & {
+        id: string;
+    }): Promise<BshResponse<CacheInfo> | undefined>;
+    search(params: BshCallbackParamsWithPayload<BshSearch, CacheInfo>): Promise<BshResponse<CacheInfo> | undefined>;
+    names(params: BshCallbackParams<unknown, string>): Promise<BshResponse<string> | undefined>;
+    clearById(params: BshCallbackParams<unknown, CacheRemoveResponse> & {
+        id: string;
+    }): Promise<BshResponse<CacheRemoveResponse> | undefined>;
+    clearAll(params: BshCallbackParams<unknown, CacheRemoveResponse>): Promise<BshResponse<CacheRemoveResponse> | undefined>;
+}
+
+declare class ApiKeyService {
+    private readonly client;
+    private readonly baseEndpoint;
+    constructor(client: BshClient);
+    create(params: BshCallbackParamsWithPayload<BshApiKeysForm, BshApiKeys>): Promise<BshResponse<BshApiKeys> | undefined>;
+    details(params: BshCallbackParams<unknown, BshApiKeys> & {
+        id: number;
+    }): Promise<BshResponse<BshApiKeys> | undefined>;
+    revoke(params: BshCallbackParams<unknown, BshApiKeys> & {
+        id: number;
+    }): Promise<BshResponse<BshApiKeys> | undefined>;
+    getById(params: BshCallbackParams<unknown, BshApiKeys> & {
+        id: string;
+    }): Promise<BshResponse<BshApiKeys> | undefined>;
+    search(params: BshCallbackParamsWithPayload<BshSearch<BshApiKeys> | undefined, BshApiKeys>): Promise<BshResponse<BshApiKeys> | undefined>;
+    list(params: BshCallbackParams<unknown, BshApiKeys> & {
+        queryParams?: {
+            page?: string;
+            size?: string;
+            sort?: string;
+            filter?: string;
+        };
+    }): Promise<BshResponse<BshApiKeys> | undefined>;
+    deleteById(params: BshCallbackParams<unknown, BshApiKeys> & {
+        id: string;
+    }): Promise<BshResponse<BshApiKeys> | undefined>;
+}
+
+type BshCallbackParams<T = unknown, R = T> = {
+    onSuccess?: (response: BshResponse<R>) => void;
+    onDownload?: (blob: Blob) => void;
+    onError?: (error: BshError) => void;
+};
+type BshCallbackParamsWithPayload<T = unknown, R = T> = BshCallbackParams<T, R> & {
+    payload: T;
+};
+type BshSearchCallbackParams<T, R = T> = BshCallbackParamsWithPayload<BshSearch<T>, R>;
+
+type BshClientFnParams<T = unknown, R = T> = {
+    path: string;
+    options: {
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+        responseType?: 'json' | 'blob' | 'text' | 'arrayBuffer';
+        requestFormat?: 'json' | 'text' | 'form';
+        body?: T | BshSearch<T> | unknown;
+        formData?: FormData;
+        queryParams?: Record<string, string>;
+        headers?: Record<string, string>;
+    };
+    bshOptions: BshCallbackParams<T, R>;
+    api?: string;
+};
+type BshClientFn = <T = unknown>(params: BshClientFnParams<T>) => Promise<Response>;
+declare const defaultClientFn: BshClientFn;
+type AuthToken = {
+    type: 'JWT' | 'APIKEY';
+    token: string;
+};
+type BshAuthFn = () => Promise<AuthToken | undefined | null>;
+type BshRefreshTokenFn = () => Promise<string | undefined | null>;
+type BshPostInterceptor<T = any> = (result: BshResponse<T>, params?: BshClientFnParams<T>) => Promise<BshResponse<T>>;
+type BshPreInterceptor<T = any> = (params: BshClientFnParams<T>) => Promise<BshClientFnParams<T>>;
+type BshErrorInterceptor<T = any> = (error: BshError, response?: BshResponse<T>, params?: BshClientFnParams<T>) => Promise<BshError | undefined>;
+
+export { type AuthToken as A, type BshClientFn as B, type CacheRemoveResponse as C, type EntityFnParams as E, ImageService as I, MailingService as M, SettingsService as S, UserService as U, type BshAuthFn as a, BshEngine as b, type BshClientFnParams as c, defaultClientFn as d, type BshRefreshTokenFn as e, type BshPostInterceptor as f, type BshPreInterceptor as g, type BshErrorInterceptor as h, BshClient as i, type BshCallbackParams as j, type BshCallbackParamsWithPayload as k, type BshSearchCallbackParams as l, type EntityFnParamsWithPayload as m, type EntitySearchFnParams as n, EntityService as o, AuthService as p, BshUtilsService as q, CachingService as r, ApiKeyService as s };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@bshsolutions/sdk-beta",
+  "version": "0.0.2-beta",
+  "description": "TypeScript SDK for integrating with BSH Engine - API services and utilities",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js",
+      "require": "./dist/client/index.js"
+    },
+    "./services": {
+      "types": "./dist/services/index.d.ts",
+      "import": "./dist/services/index.js",
+      "require": "./dist/services/index.js"
+    },
+    "./services/core": {
+      "types": "./dist/services/core/index.d.ts",
+      "import": "./dist/services/core/index.js",
+      "require": "./dist/services/core/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist",
+    "update-demos": "bash scripts/update-demos.sh",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "bsh",
+    "bsh-engine",
+    "sdk",
+    "api",
+    "typescript",
+    "client"
+  ],
+  "author": "Bousalih Hamza <hamza.bousalih.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bshgenerator/bshengine.sdk.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^2.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^2.0.0"
+  },
+  "overrides": {
+    "esbuild": "^0.25.0"
+  }
+}