@myco-dev/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,512 @@
+// src/config.ts
+function getBaseUrl(config) {
+  if (config.baseUrl) {
+    return config.baseUrl;
+  }
+  if (typeof window === "undefined") {
+    return "http://localhost:6926";
+  }
+  const isLocal = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1";
+  return isLocal ? "http://localhost:6926" : "https://api.myco.com";
+}
+function getAuthPortalUrl() {
+  if (typeof window === "undefined") {
+    return "http://localhost:5173";
+  }
+  const isLocal = window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1";
+  return isLocal ? "http://localhost:5173" : "https://myco.com";
+}
+
+// src/auth.ts
+import { createAuthClient } from "better-auth/react";
+import { jwtClient } from "better-auth/client/plugins";
+var JWT_COOKIE_NAME = "app_jwt";
+function storeJwtCookie(jwt) {
+  if (typeof document === "undefined") return;
+  const maxAge = 60 * 60 * 24 * 7;
+  document.cookie = `${JWT_COOKIE_NAME}=${jwt}; path=/; max-age=${maxAge}; samesite=lax`;
+}
+function clearJwtCookie() {
+  if (typeof document === "undefined") return;
+  document.cookie = `${JWT_COOKIE_NAME}=; path=/; max-age=0`;
+}
+function getCurrentUrl() {
+  if (typeof window === "undefined") return "";
+  return window.location.href;
+}
+var jwtCapturePlugin = {
+  id: "jwt-capture",
+  fetchPlugins: [
+    {
+      id: "jwt-capture-fetch",
+      name: "JWT Capture",
+      hooks: {
+        onSuccess: (context) => {
+          const jwt = context.response.headers.get("set-auth-jwt");
+          if (jwt) {
+            storeJwtCookie(jwt);
+          }
+        }
+      }
+    }
+  ]
+};
+function createAuth(config) {
+  const authClient = createAuthClient({
+    baseURL: getBaseUrl(config),
+    basePath: "/auth",
+    fetchOptions: {
+      credentials: "include"
+    },
+    plugins: [jwtClient(), jwtCapturePlugin]
+  });
+  return {
+    /**
+     * Redirect to the federated login page.
+     * @param returnTo - URL to return to after login (defaults to current page)
+     */
+    login(returnTo) {
+      if (typeof window === "undefined") return;
+      const authPortalUrl = getAuthPortalUrl();
+      const returnUrl = encodeURIComponent(returnTo || getCurrentUrl());
+      window.location.href = `${authPortalUrl}/federated/login?return_to=${returnUrl}`;
+    },
+    /**
+     * Sign out the current user and clear session.
+     */
+    async logout() {
+      await authClient.signOut();
+      clearJwtCookie();
+    },
+    /**
+     * Get the current session (React hook).
+     * Returns { data: session, isPending, error, refetch }
+     */
+    useSession: () => authClient.useSession(),
+    /**
+     * Get session data (non-hook version for use outside React components).
+     */
+    getSession: () => authClient.getSession()
+  };
+}
+
+// src/workspaces.ts
+function createWorkspaces(getConfig, setWorkspaceId, apiRequest, ensureWorkspace) {
+  return {
+    /**
+     * Ensure a workspace is set up for the current user.
+     * Called automatically during SDK initialization.
+     * Call manually after login if redirectOnUnauth was false.
+     */
+    ensure: ensureWorkspace,
+    /**
+     * List all workspaces the current user has access to.
+     */
+    async list() {
+      return apiRequest("/api/workspaces");
+    },
+    /**
+     * Get the current workspace details.
+     */
+    async current() {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      return apiRequest(`/api/workspaces/${config.workspaceId}`);
+    },
+    /**
+     * Switch to a different workspace.
+     */
+    switch(workspaceId) {
+      setWorkspaceId(workspaceId);
+    },
+    /**
+     * Create a new workspace.
+     */
+    async create(name) {
+      return apiRequest("/api/workspaces", {
+        method: "POST",
+        body: JSON.stringify({ name })
+      });
+    },
+    /**
+     * Update the current workspace.
+     */
+    async update(data) {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      return apiRequest(`/api/workspaces/${config.workspaceId}`, {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      });
+    },
+    /**
+     * Delete the current workspace.
+     */
+    async delete() {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      await apiRequest(`/api/workspaces/${config.workspaceId}`, {
+        method: "DELETE"
+      });
+    },
+    /**
+     * Get members of the current workspace.
+     */
+    async getMembers() {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      return apiRequest(`/api/workspaces/${config.workspaceId}/members`);
+    },
+    /**
+     * Add a member to the current workspace.
+     */
+    async addMember(userId, role = "member") {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      return apiRequest(`/api/workspaces/${config.workspaceId}/members`, {
+        method: "POST",
+        body: JSON.stringify({ userId, role })
+      });
+    },
+    /**
+     * Remove a member from the current workspace.
+     */
+    async removeMember(userId) {
+      const config = getConfig();
+      if (!config.workspaceId) {
+        throw new Error("No workspace configured. Call workspaces.ensure() first.");
+      }
+      await apiRequest(`/api/workspaces/${config.workspaceId}/members/${userId}`, {
+        method: "DELETE"
+      });
+    }
+  };
+}
+
+// src/hooks/records.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;
+        }
+      );
+    }
+  };
+}
+
+// src/data.ts
+function createData(apiRequest) {
+  const hooks = createRecordsHooks(apiRequest);
+  return {
+    ...hooks,
+    /**
+     * Get all entities for the current app.
+     */
+    async getEntities() {
+      return apiRequest("/api/entities");
+    },
+    /**
+     * Get a single entity by slug.
+     */
+    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`, {
+        method: "POST",
+        body: JSON.stringify({ data })
+      });
+    },
+    /**
+     * Update an existing record.
+     */
+    async updateRecord(entitySlug, recordId, data) {
+      return apiRequest(`/api/entities/${entitySlug}/records/${recordId}`, {
+        method: "PATCH",
+        body: JSON.stringify({ data })
+      });
+    },
+    /**
+     * Delete a record.
+     */
+    async deleteRecord(entitySlug, recordId) {
+      await apiRequest(`/api/entities/${entitySlug}/records/${recordId}`, {
+        method: "DELETE"
+      });
+    },
+    /**
+     * Batch get multiple records by IDs.
+     */
+    async batchGetRecords(entitySlug, ids) {
+      const response = await apiRequest(
+        `/api/entities/${entitySlug}/records/batch`,
+        {
+          method: "POST",
+          body: JSON.stringify({ ids })
+        }
+      );
+      return response.records;
+    }
+  };
+}
+
+// src/api-client.ts
+var ApiError = class extends Error {
+  constructor(status, body, path) {
+    super(`API Error ${status} on ${path}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.path = path;
+    this.name = "ApiError";
+  }
+};
+function createApiClient(getConfig, ready) {
+  return async function apiRequest(path, options = {}) {
+    await ready;
+    const config = getConfig();
+    const baseUrl = getBaseUrl(config);
+    const headers = new Headers(options.headers);
+    if (!headers.has("Content-Type") && options.body) {
+      headers.set("Content-Type", "application/json");
+    }
+    headers.set("Myco-App-Key", config.appKey);
+    if (config.workspaceId) {
+      headers.set("Myco-Workspace-Id", config.workspaceId);
+    }
+    const response = await fetch(`${baseUrl}${path}`, {
+      ...options,
+      headers,
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ApiError(response.status, errorText, path);
+    }
+    const contentType = response.headers.get("Content-Type");
+    if (!contentType?.includes("application/json")) {
+      return void 0;
+    }
+    return response.json();
+  };
+}
+
+// src/index.ts
+var WORKSPACE_STORAGE_KEY = "myco_workspace_id";
+function getStoredWorkspaceId() {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    return localStorage.getItem(WORKSPACE_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+function storeWorkspaceId(workspaceId) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(WORKSPACE_STORAGE_KEY, workspaceId);
+  } catch {
+  }
+}
+function clearStoredWorkspaceId() {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.removeItem(WORKSPACE_STORAGE_KEY);
+  } catch {
+  }
+}
+function createMycoSDK(appKey, options = {}) {
+  const { redirectOnUnauth = true } = options;
+  const initialConfig = {
+    appKey,
+    workspaceId: void 0,
+    baseUrl: options.baseUrl
+  };
+  let config = { ...initialConfig };
+  const getConfig = () => config;
+  const setWorkspaceId = (workspaceId) => {
+    config = { ...config, workspaceId };
+    storeWorkspaceId(workspaceId);
+  };
+  let readyResolve;
+  let readyReject;
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  const apiRequest = createApiClient(getConfig, ready);
+  const auth = createAuth(config);
+  async function joinApp() {
+    const baseUrl = getBaseUrl(config);
+    const response = await fetch(`${baseUrl}/api/app/join`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Myco-App-Key": appKey
+      },
+      credentials: "include"
+    });
+    if (response.status === 401) {
+      throw new Error("UNAUTHENTICATED");
+    }
+    if (!response.ok) {
+      throw new Error(`Join failed: ${response.status}`);
+    }
+    return response.json();
+  }
+  async function ensureWorkspace() {
+    const storedId = getStoredWorkspaceId();
+    if (storedId) {
+      try {
+        const response2 = await joinApp();
+        if (response2.success && response2.workspaceId) {
+          setWorkspaceId(response2.workspaceId);
+          return;
+        }
+      } catch (error) {
+        if (error instanceof Error && error.message === "UNAUTHENTICATED") {
+          clearStoredWorkspaceId();
+          throw error;
+        }
+        clearStoredWorkspaceId();
+      }
+    }
+    const response = await joinApp();
+    if (response.success && response.workspaceId) {
+      setWorkspaceId(response.workspaceId);
+    }
+  }
+  (async () => {
+    try {
+      await ensureWorkspace();
+      readyResolve();
+    } catch (error) {
+      if (error instanceof Error && error.message === "UNAUTHENTICATED") {
+        if (redirectOnUnauth) {
+          auth.login();
+          return;
+        }
+        readyResolve();
+        return;
+      }
+      readyReject(error instanceof Error ? error : new Error(String(error)));
+    }
+  })();
+  const workspaces = createWorkspaces(getConfig, setWorkspaceId, apiRequest, ensureWorkspace);
+  return {
+    ready,
+    auth,
+    workspaces,
+    data: createData(apiRequest)
+  };
+}
+export {
+  ApiError,
+  createMycoSDK
+};

package/dist/react.d.ts

@@ -0,0 +1,101 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { MycoSDKInstance } from './index.js';
+import 'better-auth';
+import '@better-fetch/fetch';
+import './types-D2J6kXGR.js';
+import 'swr';
+
+interface AuthContextValue {
+    isLoading: boolean;
+    isLoggedIn: boolean;
+    userId?: string;
+    user?: {
+        id: string;
+        email: string;
+        name: string;
+    };
+    login: (returnTo?: string) => void;
+    logout: () => Promise<void>;
+    refresh: () => void;
+}
+interface ProtectedRouteProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+/**
+ * Provider that wraps the Myco SDK auth state for React components.
+ * Must be placed near the root of your React app.
+ *
+ * @example
+ * ```tsx
+ * import { AuthProvider } from "@myco/sdk/react";
+ * import { myco } from "./lib/myco";
+ *
+ * function App() {
+ *   return (
+ *     <AuthProvider myco={myco}>
+ *       <YourRoutes />
+ *     </AuthProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function AuthProvider({ myco, children, }: {
+    myco: MycoSDKInstance<any>;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access auth state and methods.
+ * Must be used within an AuthProvider.
+ *
+ * @example
+ * ```tsx
+ * function UserMenu() {
+ *   const { isLoggedIn, user, logout } = useAuth();
+ *
+ *   if (!isLoggedIn) return <button onClick={() => login()}>Login</button>;
+ *
+ *   return (
+ *     <div>
+ *       <span>{user?.name}</span>
+ *       <button onClick={logout}>Logout</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuth(): AuthContextValue;
+/**
+ * Hook to access the Myco SDK instance.
+ * Must be used within an AuthProvider.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const myco = useMyco<EntityTypes>();
+ *   const records = await myco.data.getRecords('property');
+ * }
+ * ```
+ */
+declare function useMyco<T extends Record<string, unknown>>(): MycoSDKInstance<T>;
+/**
+ * Component that protects its children from unauthenticated access.
+ * Redirects to Myco login if user is not authenticated.
+ *
+ * @example
+ * ```tsx
+ * // In a router
+ * <Route
+ *   path="/dashboard"
+ *   element={
+ *     <ProtectedRoute fallback={<LoadingSpinner />}>
+ *       <Dashboard />
+ *     </ProtectedRoute>
+ *   }
+ * />
+ * ```
+ */
+declare function ProtectedRoute({ children, fallback }: ProtectedRouteProps): react_jsx_runtime.JSX.Element | null;
+
+export { AuthProvider, ProtectedRoute, useAuth, useMyco };

package/dist/react.js

@@ -0,0 +1,53 @@
+// src/react.tsx
+import { createContext, useContext, useEffect } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+var MycoContext = createContext(null);
+function AuthProvider({
+  myco,
+  children
+}) {
+  const { data: session, isPending, refetch } = myco.auth.useSession();
+  const value = {
+    isLoading: isPending,
+    isLoggedIn: !!session?.user,
+    userId: session?.user?.id,
+    user: session?.user,
+    login: (returnTo) => myco.auth.login(returnTo),
+    logout: () => myco.auth.logout(),
+    refresh: refetch
+  };
+  return /* @__PURE__ */ jsx(MycoContext.Provider, { value: myco, children: /* @__PURE__ */ jsx(AuthContext.Provider, { value, children }) });
+}
+function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+}
+function useMyco() {
+  const context = useContext(MycoContext);
+  if (!context) {
+    throw new Error("useMyco must be used within an AuthProvider");
+  }
+  return context;
+}
+function ProtectedRoute({ children, fallback = null }) {
+  const { isLoading, isLoggedIn, login } = useAuth();
+  useEffect(() => {
+    if (!isLoading && !isLoggedIn) {
+      login(window.location.href);
+    }
+  }, [isLoading, isLoggedIn, login]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  return isLoggedIn ? /* @__PURE__ */ jsx(Fragment, { children }) : null;
+}
+export {
+  AuthProvider,
+  ProtectedRoute,
+  useAuth,
+  useMyco
+};

package/dist/server.d.ts

@@ -0,0 +1,48 @@
+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';
+
+/**
+ * Server-side SDK instance
+ */
+interface ServerSDK {
+    /**
+     * Make an authenticated API request to the backend.
+     * Automatically includes JWT from cookie and app headers.
+     */
+    fetch<T>(path: string, options?: RequestInit): Promise<T>;
+    auth: {
+        getVerifiedUser: () => Promise<{
+            user: VerifiedUser | null;
+            jwt: string | null;
+        }>;
+        getLoginUrl: (returnTo: string) => string;
+    };
+    workspaces: {
+        list: () => Promise<Workspace[]>;
+        current: () => Promise<Workspace>;
+        create: (name: string) => Promise<Workspace>;
+        update: (data: {
+            name?: string;
+        }) => Promise<Workspace>;
+        delete: () => Promise<void>;
+        getMembers: () => Promise<WorkspaceMember[]>;
+        addMember: (userId: string, role?: "admin" | "member") => Promise<WorkspaceMember>;
+        removeMember: (userId: string) => Promise<void>;
+    };
+    data: {
+        getEntities: () => Promise<Entity[]>;
+        getEntity: (entitySlug: string) => Promise<Entity>;
+        getRecords: (entitySlug: string, options?: GetRecordsOptions) => Promise<PaginatedResponse<EntityRecord>>;
+        getRecord: (entitySlug: string, recordId: string) => Promise<EntityRecord>;
+        createRecord: (entitySlug: string, data: Record<string, unknown>) => Promise<EntityRecord>;
+        updateRecord: (entitySlug: string, recordId: string, data: Record<string, unknown>) => Promise<EntityRecord>;
+        deleteRecord: (entitySlug: string, recordId: string) => Promise<void>;
+        batchGetRecords: (recordIds: string[]) => Promise<EntityRecord[]>;
+    };
+}
+/**
+ * Create a server-side SDK instance.
+ * Use this in loaders and actions.
+ */
+declare function createServerSDK(env: ServerEnv, request: Request): ServerSDK;
+
+export { ServerEnv, type ServerSDK, VerifiedUser, createServerSDK };