@simplix-react/react 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { EntityDefinition, OperationDefinition, ApiContractConfig, QueryKeyFactory } from '@simplix-react/contract';
+import { z } from 'zod';
+import { UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Derived query hook with options passthrough (C8 fix)
+ */
+type DerivedListHook<TData> = (parentId: string, options?: Omit<UseQueryOptions<TData[], Error>, "queryKey" | "queryFn">) => UseQueryResult<TData[]>;
+type DerivedGetHook<TData> = (id: string, options?: Omit<UseQueryOptions<TData, Error>, "queryKey" | "queryFn">) => UseQueryResult<TData>;
+type DerivedCreateHook<TInput, TOutput> = (parentId?: string, options?: Omit<UseMutationOptions<TOutput, Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, Error, TInput>;
+type DerivedUpdateHook<TInput, TOutput> = (options?: Omit<UseMutationOptions<TOutput, Error, {
+    id: string;
+    dto: TInput;
+}>, "mutationFn">) => UseMutationResult<TOutput, Error, {
+    id: string;
+    dto: TInput;
+}>;
+type DerivedDeleteHook = (options?: Omit<UseMutationOptions<void, Error, string>, "mutationFn">) => UseMutationResult<void, Error, string>;
+/**
+ * Entity hooks derived from EntityDefinition
+ */
+interface EntityHooks<TSchema extends z.ZodTypeAny, TCreate extends z.ZodTypeAny, TUpdate extends z.ZodTypeAny> {
+    useList: DerivedListHook<z.infer<TSchema>>;
+    useGet: DerivedGetHook<z.infer<TSchema>>;
+    useCreate: DerivedCreateHook<z.infer<TCreate>, z.infer<TSchema>>;
+    useUpdate: DerivedUpdateHook<z.infer<TUpdate>, z.infer<TSchema>>;
+    useDelete: DerivedDeleteHook;
+}
+/**
+ * Operation mutation hook
+ */
+type OperationMutationHook<TInput, TOutput> = (options?: Omit<UseMutationOptions<TOutput, Error, TInput>, "mutationFn">) => UseMutationResult<TOutput, Error, TInput>;
+interface OperationHooks<TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny> {
+    useMutation: OperationMutationHook<z.infer<TInput>, z.infer<TOutput>>;
+}
+
+type AnyEntityDef = EntityDefinition<z.ZodTypeAny, z.ZodTypeAny, z.ZodTypeAny>;
+type AnyOperationDef = OperationDefinition<z.ZodTypeAny, z.ZodTypeAny>;
+/**
+ * Derive React Query hooks from an API contract.
+ *
+ * For each entity, generates: useList, useGet, useCreate, useUpdate, useDelete
+ * For each operation, generates: useMutation
+ *
+ * All hooks support options passthrough (C8 fix) and
+ * cache invalidation via operations.invalidates (C7 fix).
+ */
+declare function deriveHooks<TEntities extends Record<string, AnyEntityDef>, TOperations extends Record<string, AnyOperationDef>>(contract: {
+    config: ApiContractConfig<TEntities, TOperations>;
+    client: Record<string, unknown>;
+    queryKeys: Record<string, QueryKeyFactory>;
+}): DerivedHooksResult<TEntities, TOperations>;
+type DerivedHooksResult<TEntities extends Record<string, AnyEntityDef>, TOperations extends Record<string, AnyOperationDef>> = {
+    [K in keyof TEntities]: EntityHooks<TEntities[K]["schema"], TEntities[K]["createSchema"], TEntities[K]["updateSchema"]>;
+} & {
+    [K in keyof TOperations]: TOperations[K] extends OperationDefinition<infer TInput, infer TOutput> ? OperationHooks<TInput, TOutput> : never;
+};
+
+export { type DerivedCreateHook, type DerivedDeleteHook, type DerivedGetHook, type DerivedListHook, type DerivedUpdateHook, type EntityHooks, type OperationHooks, type OperationMutationHook, deriveHooks };

package/dist/index.js

@@ -0,0 +1,109 @@
+import { useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
+
+// src/derive-hooks.ts
+function deriveHooks(contract) {
+  const { config, client, queryKeys } = contract;
+  const result = {};
+  for (const entityName of Object.keys(config.entities)) {
+    const entity = config.entities[entityName];
+    const entityClient = client[entityName];
+    const keys = queryKeys[entityName];
+    result[entityName] = createEntityHooks(entity, entityClient, keys);
+  }
+  if (config.operations) {
+    for (const opName of Object.keys(config.operations)) {
+      const operation = config.operations[opName];
+      const opClient = client[opName];
+      result[opName] = createOperationHooks(opClient, operation, queryKeys);
+    }
+  }
+  return result;
+}
+function createEntityHooks(entity, entityClient, keys, allQueryKeys) {
+  return {
+    useList(parentId, options) {
+      return useQuery({
+        queryKey: keys.list(entity.parent ? { [entity.parent.param]: parentId } : {}),
+        queryFn: () => entityClient.list(entity.parent ? parentId : void 0),
+        enabled: entity.parent ? !!parentId : true,
+        ...options
+      });
+    },
+    useGet(id, options) {
+      return useQuery({
+        queryKey: keys.detail(id),
+        queryFn: () => entityClient.get(id),
+        enabled: !!id,
+        ...options
+      });
+    },
+    useCreate(parentId, options) {
+      const queryClient = useQueryClient();
+      return useMutation({
+        mutationFn: (dto) => {
+          if (entity.parent && parentId) {
+            return entityClient.create(parentId, dto);
+          }
+          return entityClient.create(dto);
+        },
+        onSuccess: (...args) => {
+          queryClient.invalidateQueries({ queryKey: keys.all });
+          options?.onSuccess?.(...args);
+        },
+        ...omit(options, ["onSuccess"])
+      });
+    },
+    useUpdate(options) {
+      const queryClient = useQueryClient();
+      return useMutation({
+        mutationFn: ({ id, dto }) => entityClient.update(id, dto),
+        onSuccess: (...args) => {
+          queryClient.invalidateQueries({ queryKey: keys.all });
+          options?.onSuccess?.(...args);
+        },
+        ...omit(options, ["onSuccess"])
+      });
+    },
+    useDelete(options) {
+      const queryClient = useQueryClient();
+      return useMutation({
+        mutationFn: (id) => entityClient.delete(id),
+        onSuccess: (...args) => {
+          queryClient.invalidateQueries({ queryKey: keys.all });
+          options?.onSuccess?.(...args);
+        },
+        ...omit(options, ["onSuccess"])
+      });
+    }
+  };
+}
+function createOperationHooks(opClient, operation, allQueryKeys) {
+  return {
+    useMutation(options) {
+      const queryClient = useQueryClient();
+      return useMutation({
+        mutationFn: (input) => opClient(input),
+        onSuccess: (...args) => {
+          if (operation.invalidates) {
+            const keysToInvalidate = operation.invalidates(allQueryKeys, {});
+            for (const key of keysToInvalidate) {
+              queryClient.invalidateQueries({ queryKey: key });
+            }
+          }
+          options?.onSuccess?.(...args);
+        },
+        ...omit(options, ["onSuccess"])
+      });
+    }
+  };
+}
+function omit(obj, keys) {
+  if (!obj) return {};
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+
+export { deriveHooks };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@simplix-react/react",
+  "version": "0.0.1",
+  "description": "React Query hooks derived from @simplix-react/contract",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist .turbo"
+  },
+  "peerDependencies": {
+    "@simplix-react/contract": "workspace:*",
+    "@tanstack/react-query": ">=5.0.0",
+    "react": ">=18.0.0",
+    "zod": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@simplix-react/config-typescript": "workspace:*",
+    "@simplix-react/contract": "workspace:*",
+    "@tanstack/react-query": "^5.0.0",
+    "@types/react": "^19.0.0",
+    "eslint": "^9.39.2",
+    "react": "^19.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0",
+    "zod": "^4.0.0"
+  }
+}