@reviza/api-client 1.0.0-SNAPSHOT-1c195465 → 1.0.0-SNAPSHOT-b1d8a2de

package/dist/index.js

@@ -0,0 +1,433 @@
+/**
+ * Typed API client — wraps generated controller actions with axios.
+ */
+import axios, { isAxiosError } from "axios";
+import { AuthController, CategoryController, ConfigController, DashboardController, DemoRequestController, FacilityController, FacilityDocumentController, FrontendErrorController, FrontendRouteController, MapController, MeController, NotificationSettingsController, OrganizationController, PermissionController, RelatedFacilityController, RevisionController, RevisionDocumentController, RevisionIssueController, SearchController, UserController, } from "./controllers";
+import { ActionLogController, MapController as SystemMapController, OrganizationController as SystemOrganizationController, PermissionController as SystemPermissionController, UserController as SystemUserController, } from "./controllers/System/index.js";
+// ── helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Convert a typed payload that contains `File` / `Blob` fields into a
+ * `FormData` object ready for multipart upload.
+ *
+ * Axios automatically adds the correct `Content-Type: multipart/form-data; boundary=…`
+ * header when it detects a `FormData` body — do NOT set Content-Type manually,
+ * or the boundary will be missing and the server will reject the request.
+ *
+ * Array values are appended with the `key[]` convention expected by Laravel.
+ * Boolean values are serialised as `"1"` / `"0"`.
+ * `null` / `undefined` values are skipped.
+ */
+export function toFormData(data) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(data)) {
+        if (value === null || value === undefined)
+            continue;
+        if (value instanceof File || value instanceof Blob) {
+            form.append(key, value);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                form.append(`${key}[]`, item instanceof File || item instanceof Blob ? item : String(item));
+            }
+        }
+        else if (typeof value === "boolean") {
+            form.append(key, value ? "1" : "0");
+        }
+        else {
+            form.append(key, String(value));
+        }
+    }
+    return form;
+}
+export async function readBlob(data) {
+    return await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsDataURL(data);
+    });
+}
+export class ApiError extends Error {
+    message;
+    status;
+    constructor(message, status) {
+        super(message);
+        this.message = message;
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+export class ValidationError extends ApiError {
+    message;
+    errors;
+    constructor(message, errors) {
+        super(message, 422);
+        this.message = message;
+        this.errors = errors;
+        this.name = "ValidationError";
+    }
+}
+function makeRequest(http) {
+    return async function request(action, data, config) {
+        try {
+            const response = await http({
+                method: action.method,
+                url: action.url,
+                data,
+                ...config,
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (isAxiosError(error)) {
+                if (error.status === 422) {
+                    throw new ValidationError(error.response?.data?.message ?? "Validation error", error.response?.data?.errors ?? {});
+                }
+                throw new ApiError(error.response?.data?.message, error.response?.status ?? 500);
+            }
+            throw error;
+        }
+    };
+}
+// ── API factory ───────────────────────────────────────────────────────────────
+export function createRevizaApi(http = axios) {
+    const request = makeRequest(http);
+    return {
+        frontendError(data, config) {
+            return request(FrontendErrorController.logError(), data, config);
+        },
+        config(config) {
+            return request(ConfigController.config(), undefined, config);
+        },
+        frontendRoute(config) {
+            return request(FrontendRouteController.redirect(), undefined, config);
+        },
+        search(config) {
+            return request(SearchController.search(), undefined, config);
+        },
+        dashboard: {
+            categoryTree(config) {
+                return request(DashboardController.categoryTree(), undefined, config);
+            },
+            facilityList(config) {
+                return request(DashboardController.facilityList(), undefined, config);
+            }
+        },
+        demo: {
+            index(config) {
+                return request(DemoRequestController.index(), undefined, config);
+            },
+            request(data, config) {
+                return request(DemoRequestController.store(), data, config);
+            }
+        },
+        auth: {
+            login(data, config) {
+                return request(AuthController.login(), data, config);
+            },
+            logout(config) {
+                return request(AuthController.logout(), undefined, config);
+            },
+            forgotPassword(data, config) {
+                return request(AuthController.forgotPassword(), data, config);
+            },
+            resetPassword(token, data, config) {
+                return request(AuthController.resetPassword({ token }), data, config);
+            },
+            register(token, data, config) {
+                return request(AuthController.register({ token }), data, config);
+            },
+            verifyRegistrationToken(token, config) {
+                return request(AuthController.verifyRegistrationToken({ token }), undefined, config);
+            },
+        },
+        me: {
+            get(config) {
+                return request(MeController.me(), undefined, config);
+            },
+            update(data, config) {
+                return request(MeController.update(), data, config);
+            },
+            changePassword(data, config) {
+                return request(MeController.changePassword(), data, config);
+            },
+            updateSettings(data, config) {
+                return request(MeController.updateSettings(), data, config);
+            },
+            tutorial(config) {
+                return request(MeController.tutorial(), undefined, config);
+            },
+        },
+        notificationSettings: {
+            show(config) {
+                return request(NotificationSettingsController.show(), undefined, config);
+            },
+            update(data, config) {
+                return request(NotificationSettingsController.update(), data, config);
+            },
+        },
+        organizations: {
+            index(config) {
+                return request(OrganizationController.index(), undefined, config);
+            },
+            show(organization, config) {
+                return request(OrganizationController.show({ organization }), undefined, config);
+            },
+            update(organization, data, config) {
+                return request(OrganizationController.update({ organization }), data, config);
+            },
+            getSubscriptions(organization, config) {
+                return request(OrganizationController.getSubscriptions({ organization }), undefined, config);
+            },
+        },
+        users: {
+            organizationUsers(organization, config) {
+                return request(UserController.organizationUsers({ organization }), undefined, config);
+            },
+            invite(organization, data, config) {
+                return request(UserController.invite({ organization }), data, config);
+            },
+            destroy(organization, user, config) {
+                return request(UserController.destroy({ organization, user }), undefined, config);
+            },
+        },
+        permissions: {
+            show(organization, user, config) {
+                return request(PermissionController.show({ organization, user }), undefined, config);
+            },
+            update(organization, user, data, config) {
+                return request(PermissionController.update({ organization, user }), data, config);
+            },
+        },
+        categories: {
+            index(config) {
+                return request(CategoryController.index(), undefined, config);
+            },
+            show(category, config) {
+                return request(CategoryController.show({ category }), undefined, config);
+            },
+            store(data, config) {
+                return request(CategoryController.store(), data, config);
+            },
+            update(category, data, config) {
+                return request(CategoryController.update({ category }), data, config);
+            },
+            destroy(category, config) {
+                return request(CategoryController.destroy({ category }), undefined, config);
+            },
+        },
+        maps: {
+            index(category, config) {
+                return request(MapController.index({ category }), undefined, config);
+            },
+        },
+        facilities: {
+            index(category, config) {
+                return request(FacilityController.index({ category }), undefined, config);
+            },
+            show(category, facility, config) {
+                return request(FacilityController.show({ category, facility }), undefined, config);
+            },
+            store(category, data, config) {
+                return request(FacilityController.store({ category }), data, config);
+            },
+            update(category, facility, data, config) {
+                return request(FacilityController.update({ category, facility }), data, config);
+            },
+            destroy(category, facility, config) {
+                return request(FacilityController.destroy({ category, facility }), undefined, config);
+            },
+            resolveIssue(category, facility, issue, data, config) {
+                return request(FacilityController.resolveIssue({ category, facility, issue }), data, config);
+            },
+            qrCode(category, facility, config) {
+                config = { responseType: "blob", ...config };
+                return request(FacilityController.viewQrCode({ category, facility }), undefined, config);
+            },
+            viewPicture(category, facility, config) {
+                config = { responseType: "blob", ...config };
+                return request(FacilityController.viewPicture({ category, facility }), undefined, config);
+            },
+            storePicture(category, facility, data, config) {
+                config = { ...config, headers: { 'Content-Type': 'multipart/form-data' } };
+                return request(FacilityController.storePicture({ category, facility }), toFormData(data), config);
+            },
+            deletePicture(category, facility, config) {
+                return request(FacilityController.deletePicture({ category, facility }), undefined, config);
+            },
+            mapExtent(facility, map, config) {
+                return request(FacilityController.getMapExtent({ facility, map }), undefined, config);
+            },
+        },
+        relatedFacilities: {
+            options(category, facility, config) {
+                return request(RelatedFacilityController.options({ category, facility }), undefined, config);
+            },
+            store(category, facility, data, config) {
+                return request(RelatedFacilityController.store({ category, facility }), data, config);
+            },
+            delete(category, facility, relatedFacility, config) {
+                return request(RelatedFacilityController.destroy({ category, facility, relatedFacility }), config);
+            },
+        },
+        facilityDocuments: {
+            index(category, facility, config) {
+                return request(FacilityDocumentController.index({ category, facility }), undefined, config);
+            },
+            store(category, facility, data, config) {
+                config = { ...config, headers: { 'Content-Type': 'multipart/form-data' } };
+                return request(FacilityDocumentController.store({ category, facility }), toFormData(data), config);
+            },
+            update(category, facility, document, data, config) {
+                return request(FacilityDocumentController.update({ category, facility, document }), data, config);
+            },
+            destroy(category, facility, document, config) {
+                return request(FacilityDocumentController.destroy({ category, facility, document }), undefined, config);
+            },
+            download(category, facility, document, preview, config) {
+                config = { ...config, responseType: "blob", params: { preview: preview } };
+                return request(FacilityDocumentController.download({ category, facility, document }), undefined, config);
+            },
+        },
+        revisions: {
+            index(category, facility, config) {
+                return request(RevisionController.index({ category, facility }), undefined, config);
+            },
+            show(category, facility, revision, config) {
+                return request(RevisionController.show({ category, facility, revision }), undefined, config);
+            },
+            store(category, facility, data, config) {
+                return request(RevisionController.store({ category, facility }), data, config);
+            },
+            update(category, facility, revision, data, config) {
+                return request(RevisionController.update({ category, facility, revision }), data, config);
+            },
+            destroy(category, facility, revision, config) {
+                return request(RevisionController.destroy({ category, facility, revision }), undefined, config);
+            },
+        },
+        revisionIssues: {
+            index(category, facility, revision, config) {
+                return request(RevisionIssueController.index({ category, facility, revision }), undefined, config);
+            },
+            show(category, facility, revision, issue, config) {
+                return request(RevisionIssueController.show({ category, facility, revision, issue }), undefined, config);
+            },
+            destroy(category, facility, revision, issue, config) {
+                return request(RevisionIssueController.destroy({
+                    category,
+                    facility,
+                    revision,
+                    issue
+                }), undefined, config);
+            },
+            getForCategory(category, config) {
+                return request(RevisionIssueController.getForCategory({ category }), undefined, config);
+            }
+        },
+        revisionDocuments: {
+            index(category, facility, revision, config) {
+                return request(RevisionDocumentController.index({ category, facility, revision }), undefined, config);
+            },
+            store(category, facility, revision, data, config) {
+                config = { ...config, headers: { 'Content-Type': 'multipart/form-data' } };
+                return request(RevisionDocumentController.store({
+                    category,
+                    facility,
+                    revision
+                }), toFormData(data), config);
+            },
+            update(category, facility, revision, document, data, config) {
+                return request(RevisionDocumentController.update({
+                    category,
+                    facility,
+                    revision,
+                    document
+                }), data, config);
+            },
+            destroy(category, facility, revision, document, config) {
+                return request(RevisionDocumentController.destroy({
+                    category,
+                    facility,
+                    revision,
+                    document
+                }), undefined, config);
+            },
+            download(category, facility, revision, document, preview, config) {
+                config = { ...config, responseType: "blob", params: { preview: preview } };
+                return request(RevisionDocumentController.download({
+                    category,
+                    facility,
+                    revision,
+                    document
+                }), undefined, config);
+            },
+        },
+        // ── System (admin) endpoints ───────────────────────────────────────────
+        system: {
+            actionLog: {
+                index(config) {
+                    return request(ActionLogController.index(), undefined, config);
+                },
+                show(transaction, config) {
+                    return request(ActionLogController.show({ transaction }), undefined, config);
+                },
+                revert(transaction, config) {
+                    return request(ActionLogController.revert({ transaction }), undefined, config);
+                },
+            },
+            maps: {
+                store(data, config) {
+                    config = { ...config, headers: { 'Content-Type': 'multipart/form-data' } };
+                    return request(SystemMapController.store(), toFormData(data), config);
+                },
+                update(map, data, config) {
+                    config = { ...config, headers: { 'Content-Type': 'multipart/form-data' } };
+                    return request(SystemMapController.update({ map }), toFormData(data), config);
+                },
+                destroy(map, config) {
+                    return request(SystemMapController.destroy({ map }), undefined, config);
+                },
+            },
+            organizations: {
+                store(data, config) {
+                    return request(SystemOrganizationController.store(), data, config);
+                },
+                destroy(organization, config) {
+                    return request(SystemOrganizationController.destroy({ organization }), undefined, config);
+                },
+                storeSubscription(organization, data, config) {
+                    return request(SystemOrganizationController.storeSubscription({ organization }), data, config);
+                },
+            },
+            permissions: {
+                show(user, config) {
+                    return request(SystemPermissionController.show({ user }), undefined, config);
+                },
+                update(user, data, config) {
+                    return request(SystemPermissionController.update({ user }), data, config);
+                },
+            },
+            users: {
+                index(config) {
+                    return request(SystemUserController.index(), undefined, config);
+                },
+                show(user, config) {
+                    return request(SystemUserController.show({ user }), undefined, config);
+                },
+                update(user, data, config) {
+                    return request(SystemUserController.update({ user }), data, config);
+                },
+                destroy(user, config) {
+                    return request(SystemUserController.destroy({ user }), undefined, config);
+                },
+                loginAsUser(user, config) {
+                    return request(SystemUserController.loginAsUser({ user }), undefined, config);
+                },
+            },
+        },
+    };
+}
+export * from "./App/Enum";
+export * from "./App/Enum/Permissions";
+export * from "./App/Enum/Notifications";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@reviza/api-client",
-    "version": "1.0.0-SNAPSHOT-1c195465",
+    "version": "1.0.0-SNAPSHOT-b1d8a2de",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",