@chill-sharp/react-client 1.1.12

package/dist/hooks.js

@@ -0,0 +1,434 @@
+/*
+ * ChillSharp is a lightweight .NET library that sits on top of Entity Framework Core
+ * and turns an existing data model into a fully working REST API with almost no setup.
+ * Copyright (C) 2025 Andrea Piovesan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { useEffect, useRef, useState } from "react";
+import { CHILL_SHARP_REACT_CLIENT_VERSION } from "./version.js";
+import { useChillSharpClient } from "./context.js";
+export function useSchema(chillType, chillViewCode = "default", cultureName, update = false) {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.getSchema(chillType, chillViewCode, cultureName, update);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client, chillType, chillViewCode, cultureName, update]);
+    return {
+        data,
+        error,
+        isLoading,
+        reload: load
+    };
+}
+export function useSchemaList(cultureName) {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.getSchemaList(cultureName);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client, cultureName]);
+    return {
+        data,
+        error,
+        isLoading,
+        reload: load
+    };
+}
+export function useText(request) {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.getText(request);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client, request]);
+    return {
+        data,
+        error,
+        isLoading,
+        reload: load
+    };
+}
+export function useTexts(requests) {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.getTexts(requests);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client, requests]);
+    return {
+        data,
+        error,
+        isLoading,
+        reload: load
+    };
+}
+export function useVersion() {
+    return CHILL_SHARP_REACT_CLIENT_VERSION;
+}
+export function useTest() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.test();
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client]);
+    return {
+        data,
+        error,
+        isLoading,
+        reload: load
+    };
+}
+export function useCurrentUserPreferences() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const load = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.getCurrentUserPreferences();
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => { void load(); }, [client]);
+    return { data, error, isLoading, reload: load };
+}
+export function useQueryMutation() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const execute = async (...args) => {
+        const payload = args[0];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.query(payload);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        data,
+        error,
+        isLoading,
+        execute,
+        reset: () => {
+            setData(null);
+            setError(null);
+            setIsLoading(false);
+        }
+    };
+}
+export function useLookupMutation() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const execute = async (...args) => {
+        const payload = args[0];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.lookup(payload);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        data,
+        error,
+        isLoading,
+        execute,
+        reset: () => {
+            setData(null);
+            setError(null);
+            setIsLoading(false);
+        }
+    };
+}
+export function useAutocompleteMutation() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const execute = async (...args) => {
+        const payload = args[0];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.autocomplete(payload);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        data,
+        error,
+        isLoading,
+        execute,
+        reset: () => {
+            setData(null);
+            setError(null);
+            setIsLoading(false);
+        }
+    };
+}
+export function useValidateMutation() {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const execute = async (...args) => {
+        const payload = args[0];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await client.validate(payload);
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        data,
+        error,
+        isLoading,
+        execute,
+        reset: () => {
+            setData(null);
+            setError(null);
+            setIsLoading(false);
+        }
+    };
+}
+export function useEntityMutation(action) {
+    const client = useChillSharpClient();
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const execute = async (...args) => {
+        const payload = args[0];
+        setIsLoading(true);
+        setError(null);
+        try {
+            let response;
+            switch (action) {
+                case "find":
+                    response = await client.find(payload);
+                    break;
+                case "create":
+                    response = await client.create(payload);
+                    break;
+                case "update":
+                    response = await client.update(payload);
+                    break;
+                default:
+                    await client.delete(payload);
+                    response = null;
+                    break;
+            }
+            setData(response);
+            return response;
+        }
+        catch (err) {
+            setError(err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        data,
+        error,
+        isLoading,
+        execute,
+        reset: () => {
+            setData(null);
+            setError(null);
+            setIsLoading(false);
+        }
+    };
+}
+export function useEntityChanges(chillType, onChanges, guid) {
+    const client = useChillSharpClient();
+    const onChangesRef = useRef(onChanges);
+    const unsubscribeRef = useRef(null);
+    const [error, setError] = useState(null);
+    const [isSubscribed, setIsSubscribed] = useState(false);
+    useEffect(() => {
+        onChangesRef.current = onChanges;
+    }, [onChanges]);
+    useEffect(() => {
+        let isDisposed = false;
+        setError(null);
+        setIsSubscribed(false);
+        unsubscribeRef.current = null;
+        void client
+            .subscribeToEntityChanges(chillType, async (changes) => {
+            await onChangesRef.current(changes);
+        }, guid)
+            .then((subscription) => {
+            if (isDisposed) {
+                void subscription.unsubscribe();
+                return;
+            }
+            unsubscribeRef.current = () => subscription.unsubscribe();
+            setIsSubscribed(true);
+        })
+            .catch((err) => {
+            if (!isDisposed) {
+                setError(err);
+                setIsSubscribed(false);
+            }
+        });
+        return () => {
+            isDisposed = true;
+            setIsSubscribed(false);
+            if (unsubscribeRef.current) {
+                void unsubscribeRef.current();
+                unsubscribeRef.current = null;
+            }
+        };
+    }, [client, chillType, guid]);
+    return {
+        error,
+        isSubscribed
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { ChillSharpProvider, useChillSharpClient } from "./context.js";
+export { useAutocompleteMutation, useCurrentUserPreferences, useEntityChanges, useEntityMutation, useQueryMutation, useSchema, useSchemaList, useTest, useText, useTexts, useValidateMutation, useVersion } from "./hooks.js";
+export type { ChillSharpProviderProps } from "./context.js";
+export type { UseChillAsyncState, UseChillMutationState, UseChillSubscriptionState } from "./hooks.js";
+export { CHILL_SHARP_REACT_CLIENT_VERSION } from "./version.js";
+export { API_BASE_PATH, ChillSharpClient, ChillSharpClientError, PermissionAction, PermissionEffect, PermissionScope } from "@chill-sharp/ts-client";
+export type { AuthPermissionRule, AuthPermissionRuleItem, AuthRoleDetailsResponse, AuthRoleListItem, AuthRolePermissions, AuthTokenResponse, AuthUserDetailsResponse, AuthUserListItem, ChillDtoEntity, ChillUserPreferences, ChillDtoEntityOptions, ChillDtoMenuItem, ChillDtoProperty, ChillDtoPropertySchema, ChillDtoQuery, ChillDtoSchema, ChillDtoSchemaRelation, ChillDtoSchemaRelationLabel, ChillDtoSchemaListItem, ChillAttachmentUploadFile, ChillAttachmentUploadOptions, ChillEntityChangeAction, ChillEntityChangeCallback, ChillEntityChangeNotification, ChillEntityChangeSubscription, ChillOrdering, ChillPagination, ChillSharpClientOptions, GetAuthPermissionsResponse, GetTextRequest, GetTextResponse, JsonObject, JsonPrimitive, JsonValue, RegisterAuthIdentityRequest, SetAuthRoleRequest, SetAuthUserRequest } from "@chill-sharp/ts-client";

package/dist/index.js

@@ -0,0 +1,22 @@
+/*
+ * ChillSharp is a lightweight .NET library that sits on top of Entity Framework Core
+ * and turns an existing data model into a fully working REST API with almost no setup.
+ * Copyright (C) 2025 Andrea Piovesan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+export { ChillSharpProvider, useChillSharpClient } from "./context.js";
+export { useAutocompleteMutation, useCurrentUserPreferences, useEntityChanges, useEntityMutation, useQueryMutation, useSchema, useSchemaList, useTest, useText, useTexts, useValidateMutation, useVersion } from "./hooks.js";
+export { CHILL_SHARP_REACT_CLIENT_VERSION } from "./version.js";
+export { API_BASE_PATH, ChillSharpClient, ChillSharpClientError, PermissionAction, PermissionEffect, PermissionScope } from "@chill-sharp/ts-client";

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const CHILL_SHARP_REACT_CLIENT_VERSION = "0.1.0";

package/dist/version.js

@@ -0,0 +1,19 @@
+/*
+ * ChillSharp is a lightweight .NET library that sits on top of Entity Framework Core
+ * and turns an existing data model into a fully working REST API with almost no setup.
+ * Copyright (C) 2025 Andrea Piovesan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+export const CHILL_SHARP_REACT_CLIENT_VERSION = "0.1.0";

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@chill-sharp/react-client",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/e-500/chill-sharp.git",
+    "directory": "extra/chill-sharp-react-client"
+  },
+  "version": "1.1.12",
+  "description": "React client helpers for generic ChillSharp services",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepare": "npm run build",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "chillsharp",
+    "react",
+    "typescript",
+    "client",
+    "hooks"
+  ],
+  "author": "Andrea Piovesan",
+  "peerDependencies": {
+    "react": "^18.2.0 || ^19.0.0",
+    "@chill-sharp/ts-client": "^1.1.12"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "typescript": "^5.8.2",
+    "@chill-sharp/ts-client": "file:../chill-sharp-ts-client"
+  }
+}
+

package/src/context.tsx

@@ -0,0 +1,58 @@
+/*
+ * ChillSharp is a lightweight .NET library that sits on top of Entity Framework Core 
+ * and turns an existing data model into a fully working REST API with almost no setup.
+ * Copyright (C) 2025 Andrea Piovesan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import React, { createContext, useContext, useRef } from "react";
+import { ChillSharpClient } from "@chill-sharp/ts-client";
+import type { ChillSharpClientOptions } from "@chill-sharp/ts-client";
+
+export interface ChillSharpProviderProps {
+  baseUrl: string;
+  client?: ChillSharpClient;
+  options?: ChillSharpClientOptions;
+  children: React.ReactNode;
+}
+
+const ChillSharpContext = createContext<ChillSharpClient | null>(null);
+
+export function ChillSharpProvider(props: ChillSharpProviderProps) {
+  const clientRef = useRef<ChillSharpClient | null>(props.client ?? null);
+
+  if (props.client && clientRef.current !== props.client) {
+    clientRef.current = props.client;
+  }
+
+  if (!clientRef.current) {
+    clientRef.current = new ChillSharpClient(props.baseUrl, props.options);
+  }
+
+  return (
+    <ChillSharpContext.Provider value={clientRef.current}>
+      {props.children}
+    </ChillSharpContext.Provider>
+  );
+}
+
+export function useChillSharpClient(): ChillSharpClient {
+  const client = useContext(ChillSharpContext);
+  if (!client) {
+    throw new Error("useChillSharpClient must be used inside ChillSharpProvider.");
+  }
+
+  return client;
+}