cogsbox-state 0.5.448 → 0.5.450

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-state",
-  "version": "0.5.448",
+  "version": "0.5.450",
   "description": "React state management library with form controls and server sync",
   "type": "module",
   "main": "./dist/index.js",

package/src/CogsState.tsx

@@ -683,32 +683,60 @@ export const createCogsState = <State extends Record<StateKeys, unknown>>(
 
   return { useCogsState, setCogsOptions } as CogsApi<State>;
 };
+
+// First, let's create a proper type to extract API params from the sync schema
+type ExtractApiParamsFromSchema<T> = T extends {
+  apiParamsSchema: z.ZodObject<infer U>;
+}
+  ? { [K in keyof U]: z.infer<U[K]> }
+  : never;
+
+// Type to check if a schema has API params
+type HasApiParams<T> = T extends { apiParamsSchema: z.ZodObject<any> }
+  ? true
+  : false;
+
+// Create the proper return type for useCogsState
+type UseCogsStateFromSync<
+  TSyncSchema extends {
+    schemas: Record<
+      string,
+      { schemas: { defaultValues: any }; apiParamsSchema?: z.ZodObject<any> }
+    >;
+  },
+> = {
+  // For schemas WITH API params - require apiParams
+  <K extends keyof TSyncSchema['schemas']>(
+    stateKey: K,
+    options: HasApiParams<TSyncSchema['schemas'][K]> extends true
+      ? OptionsType<TSyncSchema['schemas'][K]['schemas']['defaultValues']> & {
+          apiParams: ExtractApiParamsFromSchema<TSyncSchema['schemas'][K]>;
+        }
+      : never
+  ): StateObject<TSyncSchema['schemas'][K]['schemas']['defaultValues']>;
+
+  // For schemas WITHOUT API params - apiParams is optional
+  <K extends keyof TSyncSchema['schemas']>(
+    stateKey: K,
+    options?: HasApiParams<TSyncSchema['schemas'][K]> extends true
+      ? never
+      : OptionsType<TSyncSchema['schemas'][K]['schemas']['defaultValues']>
+  ): StateObject<TSyncSchema['schemas'][K]['schemas']['defaultValues']>;
+};
+// Simplified approach that actually works
 export function createCogsStateFromSync<
   TSyncSchema extends {
     schemas: Record<
       string,
       {
         schemas: { defaultValues: any };
-        apiParamsSchema?: z.ZodObject<any>; // Add this type
+        apiParamsSchema?: z.ZodObject<any>;
         [key: string]: any;
       }
     >;
     notifications: Record<string, any>;
   },
->(
-  syncSchema: TSyncSchema
-): CogsApi<
-  {
-    [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['schemas']['defaultValues'];
-  },
-  {
-    [K in keyof TSyncSchema['schemas']]: TSyncSchema['schemas'][K]['apiParamsSchema'] extends z.ZodObject<
-      infer U
-    >
-      ? { [P in keyof U]: z.infer<U[P]> }
-      : never;
-  }[keyof TSyncSchema['schemas']]
-> {
+>(syncSchema: TSyncSchema) {
   const schemas = syncSchema.schemas;
   const initialState: any = {};
 
@@ -718,13 +746,44 @@ export function createCogsStateFromSync<
     initialState[key] = entry?.schemas?.defaultValues || {};
   }
 
-  // Create the cogs state with proper API params type inference
-  return createCogsState(initialState, {
+  // Create the base CogsApi
+  const baseApi = createCogsState(initialState, {
     __fromSyncSchema: true,
     __syncNotifications: syncSchema.notifications,
   });
-}
 
+  // Create a wrapper that validates API params at runtime
+  const useCogsState = <K extends keyof TSyncSchema['schemas']>(
+    stateKey: K,
+    options?: OptionsType<
+      TSyncSchema['schemas'][K]['schemas']['defaultValues']
+    > & {
+      apiParams?: any; // We'll validate this at runtime
+    }
+  ): StateObject<TSyncSchema['schemas'][K]['schemas']['defaultValues']> => {
+    // Runtime validation of API params
+    const schemaEntry = schemas[stateKey as keyof typeof schemas];
+    if (schemaEntry?.apiParamsSchema && options?.apiParams) {
+      // Validate the API params at runtime
+      const result = schemaEntry.apiParamsSchema.safeParse(options.apiParams);
+      if (!result.success) {
+        throw new Error(
+          `Invalid API params for ${String(stateKey)}: ${result.error.message}`
+        );
+      }
+    }
+
+    // Cast to the correct type since we know it's properly typed
+    return baseApi.useCogsState(stateKey as any, options as any) as StateObject<
+      TSyncSchema['schemas'][K]['schemas']['defaultValues']
+    >;
+  };
+
+  return {
+    useCogsState,
+    setCogsOptions: baseApi.setCogsOptions,
+  };
+}
 const {
   getInitialOptions,
   getValidationErrors,