@myco-dev/sdk 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 import * as better_auth from 'better-auth';
 import * as _better_fetch_fetch from '@better-fetch/fetch';
-import { M as MycoSDKConfig, W as Workspace, a as WorkspaceMember, G as GetRecordsOptions, E as Entity, P as PaginatedResponse, b as EntityRecord } from './types-D2J6kXGR.js';
-export { c as EntityField, J as JoinResponse, V as VerifiedUser } from './types-D2J6kXGR.js';
-import * as swr from 'swr';
-import { SWRResponse } from 'swr';
+import { M as MycoSDKConfig, W as Workspace, a as WorkspaceMember, G as GetRecordsOptions, P as PaginatedResponse, F as FlattenedRecord, E as Entity } from './types-75pXTdeu.js';
+export { b as EntityField, c as EntityRecord, J as JoinResponse, V as VerifiedUser } from './types-75pXTdeu.js';
+import { UseQueryResult } from '@tanstack/react-query';
 
 /**
  * Create auth namespace bound to the given config.
@@ -140,31 +139,30 @@ declare function createWorkspaces(getConfig: () => MycoSDKConfig, setWorkspaceId
     removeMember(userId: string): Promise<void>;
 };
 
+type ApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;
+/**
+ * Helper type - flattened record with data at top level.
+ */
+type TypedEntityRecord<T> = FlattenedRecord<T>;
 interface UseRecordsOptions extends Omit<GetRecordsOptions, "page"> {
     initialPage?: number;
     onPageChange?: (page: number) => void;
 }
-interface UseRecordsResult<T> extends SWRResponse<T[]> {
+type UseRecordsResult<T> = UseQueryResult<T[]> & {
     page: number;
     hasNextPage: boolean;
     hasPreviousPage: boolean;
     nextPage: () => void;
     previousPage: () => void;
     setPage: (page: number) => void;
-}
-
-type ApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;
-/**
- * Helper type that wraps entity data with record metadata.
- */
-type TypedEntityRecord<T> = Omit<EntityRecord, "data"> & {
-    data: T;
 };
 /**
  * Create data namespace bound to the given API client.
  * Accepts a generic type parameter for entity type mapping.
  */
 declare function createData<TEntities extends Record<string, unknown>>(apiRequest: ApiRequest): {
+    getRecords: <K extends keyof TEntities & string>(entitySlug: K, options?: GetRecordsOptions) => Promise<PaginatedResponse<TypedEntityRecord<TEntities[K]>>>;
+    getRecord: <K extends keyof TEntities & string>(entitySlug: K, recordId: string) => Promise<TypedEntityRecord<TEntities[K]>>;
     /**
      * Get all entities for the current app.
      */
@@ -173,14 +171,6 @@ declare function createData<TEntities extends Record<string, unknown>>(apiReques
      * Get a single entity by slug.
      */
     getEntity<K extends keyof TEntities & string>(entitySlug: K): Promise<Entity>;
-    /**
-     * Get records for an entity.
-     */
-    getRecords<K extends keyof TEntities & string>(entitySlug: K, options?: GetRecordsOptions): Promise<PaginatedResponse<TypedEntityRecord<TEntities[K]>>>;
-    /**
-     * Get a single record by ID.
-     */
-    getRecord<K extends keyof TEntities & string>(entitySlug: K, recordId: string): Promise<TypedEntityRecord<TEntities[K]>>;
     /**
      * Create a new record.
      */
@@ -197,8 +187,14 @@ declare function createData<TEntities extends Record<string, unknown>>(apiReques
      * Batch get multiple records by IDs.
      */
     batchGetRecords<K extends keyof TEntities & string>(entitySlug: K, ids: string[]): Promise<TypedEntityRecord<TEntities[K]>[]>;
+    /**
+     * React hook to fetch records with pagination.
+     */
     useRecords<K extends keyof TEntities & string>(entitySlug: K | null | undefined, options?: UseRecordsOptions): UseRecordsResult<TypedEntityRecord<TEntities[K]>>;
-    useRecord<K extends keyof TEntities & string>(entitySlug: K | null | undefined, recordId: string | null | undefined): swr.SWRResponse<TypedEntityRecord<TEntities[K]>, any, any>;
+    /**
+     * React hook to fetch a single record.
+     */
+    useRecord<K extends keyof TEntities & string>(entitySlug: K | null | undefined, recordId: string | null | undefined): UseQueryResult<TypedEntityRecord<TEntities[K]>>;
 };
 type Data<TEntities extends Record<string, unknown>> = ReturnType<typeof createData<TEntities>>;
 
@@ -250,4 +246,4 @@ interface MycoSDKInstance<TEntities extends Record<string, unknown>> {
  */
 declare function createMycoSDK<TEntities extends Record<string, unknown>>(appKey: string, options?: MycoSDKOptions): MycoSDKInstance<TEntities>;
 
-export { ApiError, Entity, EntityRecord, GetRecordsOptions, MycoSDKConfig, type MycoSDKInstance, type MycoSDKOptions, PaginatedResponse, type TypedEntityRecord, Workspace, WorkspaceMember, createMycoSDK };
+export { ApiError, Entity, GetRecordsOptions, MycoSDKConfig, type MycoSDKInstance, type MycoSDKOptions, PaginatedResponse, type TypedEntityRecord, Workspace, WorkspaceMember, createMycoSDK };

package/dist/index.js

@@ -193,86 +193,49 @@ function createWorkspaces(getConfig, setWorkspaceId, apiRequest, ensureWorkspace
   };
 }
 
-// src/hooks/records.ts
+// src/data.ts
 import { useState, useCallback } from "react";
-import useSWR from "swr";
-function createRecordsHooks(apiRequest) {
-  return {
-    useRecords(entitySlug, options) {
-      const { initialPage = 1, onPageChange, ...queryOptions } = options ?? {};
-      const [page, setPageState] = useState(initialPage);
-      const [hasNextPage, setHasNextPage] = useState(false);
-      const setPage = useCallback(
-        (newPage) => {
-          if (newPage < 1) return;
-          setPageState(newPage);
-          onPageChange?.(newPage);
-        },
-        [onPageChange]
-      );
-      const nextPage = useCallback(() => {
-        if (hasNextPage) {
-          setPage(page + 1);
-        }
-      }, [hasNextPage, page, setPage]);
-      const previousPage = useCallback(() => {
-        if (page > 1) {
-          setPage(page - 1);
-        }
-      }, [page, setPage]);
-      const swrResult = useSWR(
-        entitySlug ? ["records", entitySlug, page, queryOptions] : null,
-        async () => {
-          const params = new URLSearchParams();
-          params.set("page", String(page));
-          if (queryOptions?.pageSize !== void 0) {
-            params.set("pageSize", String(queryOptions.pageSize));
-          }
-          if (queryOptions?.sort) {
-            params.set("sort", queryOptions.sort);
-          }
-          if (queryOptions?.order) {
-            params.set("order", queryOptions.order);
-          }
-          if (queryOptions?.filter) {
-            params.set("filter", JSON.stringify(queryOptions.filter));
-          }
-          const queryString = params.toString();
-          const path = `/api/entities/${entitySlug}/records?${queryString}`;
-          const response = await apiRequest(path);
-          setHasNextPage(response.pagination.hasMore);
-          return response.records;
-        }
-      );
-      return {
-        ...swrResult,
-        page,
-        hasNextPage,
-        hasPreviousPage: page > 1,
-        nextPage,
-        previousPage,
-        setPage
-      };
-    },
-    useRecord(entitySlug, recordId) {
-      return useSWR(
-        entitySlug && recordId ? ["record", entitySlug, recordId] : null,
-        async () => {
-          const response = await apiRequest(
-            `/api/entities/${entitySlug}/records/${recordId}`
-          );
-          return response;
-        }
-      );
-    }
-  };
+import { useQuery } from "@tanstack/react-query";
+function transformRecord(raw) {
+  const record = raw.data;
+  record._id = raw.id;
+  record._createdAt = raw.createdAt;
+  record._updatedAt = raw.updatedAt;
+  return record;
 }
-
-// src/data.ts
 function createData(apiRequest) {
-  const hooks = createRecordsHooks(apiRequest);
+  const getRecords = async (entitySlug, options) => {
+    const params = new URLSearchParams();
+    if (options?.page !== void 0) {
+      params.set("page", String(options.page));
+    }
+    if (options?.pageSize !== void 0) {
+      params.set("pageSize", String(options.pageSize));
+    }
+    if (options?.sort) {
+      params.set("sort", options.sort);
+    }
+    if (options?.order) {
+      params.set("order", options.order);
+    }
+    if (options?.filter) {
+      params.set("filter", JSON.stringify(options.filter));
+    }
+    const queryString = params.toString();
+    const path = `/api/entities/${entitySlug}/records${queryString ? `?${queryString}` : ""}`;
+    const response = await apiRequest(path);
+    return {
+      ...response,
+      records: response.records.map(transformRecord)
+    };
+  };
+  const getRecord = async (entitySlug, recordId) => {
+    const raw = await apiRequest(`/api/entities/${entitySlug}/records/${recordId}`);
+    return transformRecord(raw);
+  };
   return {
-    ...hooks,
+    getRecords,
+    getRecord,
     /**
      * Get all entities for the current app.
      */
@@ -285,53 +248,25 @@ function createData(apiRequest) {
     async getEntity(entitySlug) {
       return apiRequest(`/api/entities/${entitySlug}`);
     },
-    /**
-     * Get records for an entity.
-     */
-    async getRecords(entitySlug, options) {
-      const params = new URLSearchParams();
-      if (options?.page !== void 0) {
-        params.set("page", String(options.page));
-      }
-      if (options?.pageSize !== void 0) {
-        params.set("pageSize", String(options.pageSize));
-      }
-      if (options?.sort) {
-        params.set("sort", options.sort);
-      }
-      if (options?.order) {
-        params.set("order", options.order);
-      }
-      if (options?.filter) {
-        params.set("filter", JSON.stringify(options.filter));
-      }
-      const queryString = params.toString();
-      const path = `/api/entities/${entitySlug}/records${queryString ? `?${queryString}` : ""}`;
-      return apiRequest(path);
-    },
-    /**
-     * Get a single record by ID.
-     */
-    async getRecord(entitySlug, recordId) {
-      return apiRequest(`/api/entities/${entitySlug}/records/${recordId}`);
-    },
     /**
      * Create a new record.
      */
     async createRecord(entitySlug, data) {
-      return apiRequest(`/api/entities/${entitySlug}/records`, {
+      const raw = await apiRequest(`/api/entities/${entitySlug}/records`, {
         method: "POST",
         body: JSON.stringify({ data })
       });
+      return transformRecord(raw);
     },
     /**
      * Update an existing record.
      */
     async updateRecord(entitySlug, recordId, data) {
-      return apiRequest(`/api/entities/${entitySlug}/records/${recordId}`, {
+      const raw = await apiRequest(`/api/entities/${entitySlug}/records/${recordId}`, {
         method: "PATCH",
         body: JSON.stringify({ data })
       });
+      return transformRecord(raw);
     },
     /**
      * Delete a record.
@@ -352,7 +287,61 @@ function createData(apiRequest) {
           body: JSON.stringify({ ids })
         }
       );
-      return response.records;
+      return response.records.map(transformRecord);
+    },
+    /**
+     * React hook to fetch records with pagination.
+     */
+    useRecords(entitySlug, options) {
+      const { initialPage = 1, onPageChange, ...queryOptions } = options ?? {};
+      const [page, setPageState] = useState(initialPage);
+      const [hasNextPage, setHasNextPage] = useState(false);
+      const setPage = useCallback(
+        (newPage) => {
+          if (newPage < 1) return;
+          setPageState(newPage);
+          onPageChange?.(newPage);
+        },
+        [onPageChange]
+      );
+      const nextPage = useCallback(() => {
+        if (hasNextPage) {
+          setPage(page + 1);
+        }
+      }, [hasNextPage, page, setPage]);
+      const previousPage = useCallback(() => {
+        if (page > 1) {
+          setPage(page - 1);
+        }
+      }, [page, setPage]);
+      const queryResult = useQuery({
+        queryKey: entitySlug ? ["records", entitySlug, page, queryOptions] : [],
+        queryFn: async () => {
+          const response = await getRecords(entitySlug, { ...queryOptions, page });
+          setHasNextPage(response.pagination.hasMore);
+          return response.records;
+        },
+        enabled: !!entitySlug
+      });
+      return {
+        ...queryResult,
+        page,
+        hasNextPage,
+        hasPreviousPage: page > 1,
+        nextPage,
+        previousPage,
+        setPage
+      };
+    },
+    /**
+     * React hook to fetch a single record.
+     */
+    useRecord(entitySlug, recordId) {
+      return useQuery({
+        queryKey: entitySlug && recordId ? ["record", entitySlug, recordId] : [],
+        queryFn: () => getRecord(entitySlug, recordId),
+        enabled: !!entitySlug && !!recordId
+      });
     }
   };
 }

package/dist/react.d.ts

@@ -3,8 +3,8 @@ import { ReactNode } from 'react';
 import { MycoSDKInstance } from './index.js';
 import 'better-auth';
 import '@better-fetch/fetch';
-import './types-D2J6kXGR.js';
-import 'swr';
+import './types-75pXTdeu.js';
+import '@tanstack/react-query';
 
 interface AuthContextValue {
     isLoading: boolean;

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { V as VerifiedUser, W as Workspace, a as WorkspaceMember, E as Entity, G as GetRecordsOptions, P as PaginatedResponse, b as EntityRecord, S as ServerEnv } from './types-D2J6kXGR.js';
+import { V as VerifiedUser, W as Workspace, a as WorkspaceMember, E as Entity, G as GetRecordsOptions, P as PaginatedResponse, c as EntityRecord, S as ServerEnv } from './types-75pXTdeu.js';
 
 /**
  * Server-side SDK instance

package/dist/types-75pXTdeu.d.ts

@@ -0,0 +1,86 @@
+interface JoinResponse {
+    success: boolean;
+    message?: string;
+    workspaceId?: string;
+}
+interface VerifiedUser {
+    userId: string;
+    email?: string;
+    name?: string;
+}
+interface Workspace {
+    id: string;
+    name: string;
+    slug?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface WorkspaceMember {
+    id: string;
+    userId: string;
+    workspaceId: string;
+    role: "owner" | "admin" | "member";
+    user?: {
+        id: string;
+        email: string;
+        name: string;
+    };
+    createdAt: string;
+}
+interface Entity {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string;
+    fields: EntityField[];
+}
+interface EntityField {
+    id: string;
+    name: string;
+    slug: string;
+    type: string;
+    required?: boolean;
+    options?: Record<string, unknown>;
+}
+interface EntityRecord {
+    id: string;
+    entityId: string;
+    workspaceId: string;
+    data: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Flattened record type with data spread at top level and underscore-prefixed metadata.
+ */
+type FlattenedRecord<T> = T & {
+    _id: string;
+    _createdAt: string;
+    _updatedAt: string;
+};
+interface PaginatedResponse<T> {
+    records: T[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+interface GetRecordsOptions {
+    page?: number;
+    pageSize?: number;
+    sort?: string;
+    order?: "asc" | "desc";
+    filter?: Record<string, unknown>;
+}
+interface MycoSDKConfig {
+    appKey: string;
+    workspaceId?: string;
+    baseUrl?: string;
+}
+interface ServerEnv {
+    MYCO_APP_KEY: string;
+}
+
+export type { Entity as E, FlattenedRecord as F, GetRecordsOptions as G, JoinResponse as J, MycoSDKConfig as M, PaginatedResponse as P, ServerEnv as S, VerifiedUser as V, Workspace as W, WorkspaceMember as a, EntityField as b, EntityRecord as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myco-dev/sdk",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -29,12 +29,13 @@
   "peerDependencies": {
     "react": "^18 || ^19",
     "better-auth": "^1.4",
-    "swr": "^2.4.0"
+    "@tanstack/react-query": "^5.0.0"
   },
   "dependencies": {
     "jose": "^5.0.0"
   },
   "devDependencies": {
+    "@tanstack/react-query": "^5.0.0",
     "@types/react": "^19.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"