@savvycal/appointments-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SavvyCal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# @savvycal/appointments-core
+
+TypeScript/JavaScript client library for the [SavvyCal Appointments API](https://developers.savvycal.app).
+
+## Installation
+
+```bash
+npm install @savvycal/appointments-core
+```
+
+## Usage
+
+### Creating a Client
+
+```typescript
+import { createFetchClient } from "@savvycal/appointments-core";
+
+const client = createFetchClient({
+  fetchAccessToken: async () => {
+    // Return a JWT access token
+    return "your-jwt-token";
+  },
+});
+```
+
+### Authentication
+
+The client requires a `fetchAccessToken` callback that returns a JWT token. The client automatically handles token caching and refresh when tokens expire.
+
+```typescript
+const client = createFetchClient({
+  fetchAccessToken: async () => {
+    const response = await fetch("/api/token");
+    const { token } = await response.json();
+    return token;
+  },
+});
+```
+
+### Demo Mode
+
+For development and testing, you can use demo mode:
+
+```typescript
+const client = createFetchClient({
+  demo: "demo-token",
+});
+```
+
+### Account Scoping
+
+To scope requests to a specific account, pass the `account` option:
+
+```typescript
+const client = createFetchClient({
+  account: "account-id",
+  fetchAccessToken: async () => "your-jwt-token",
+});
+```
+
+### Making API Calls
+
+The client provides typed methods for all API endpoints:
+
+```typescript
+// GET request
+const { data, error } = await client.GET("/v1/appointments/{appointment_id}", {
+  params: {
+    path: { appointment_id: "apt_123" },
+  },
+});
+
+// POST request
+const { data, error } = await client.POST("/v1/appointments", {
+  body: {
+    service_id: "svc_123",
+    start_time: "2024-01-15T10:00:00Z",
+    client: {
+      name: "John Doe",
+      email: "john@example.com",
+    },
+  },
+});
+```
+
+### Using Operation Functions
+
+The package also exports typed operation functions for common actions:
+
+```typescript
+import {
+  createFetchClient,
+  getAppointment,
+  cancelAppointment,
+  listServices,
+} from "@savvycal/appointments-core";
+
+const client = createFetchClient({
+  fetchAccessToken: async () => "your-jwt-token",
+});
+
+// Get an appointment
+const appointment = await getAppointment(client, {
+  appointment_id: "apt_123",
+});
+
+// Cancel an appointment
+await cancelAppointment(
+  client,
+  { appointment_id: "apt_123" },
+  { reason: "Schedule conflict" },
+);
+
+// List services
+const services = await listServices(client);
+```
+
+## Type Utilities
+
+The package exports type utilities for extracting parameter types from API paths:
+
+```typescript
+import type {
+  PathParams,
+  QueryParams,
+  RequestBody,
+} from "@savvycal/appointments-core";
+
+// Extract path parameters
+type AppointmentPath = PathParams<"/v1/appointments/{appointment_id}", "get">;
+// => { appointment_id: string }
+
+// Extract query parameters
+type SlotsQuery = QueryParams<"/v1/public/services/{service_id}/slots", "get">;
+// => { from: string; until: string; time_zone?: string; ... }
+
+// Extract request body type
+type CreateAppointmentBody = RequestBody<"/v1/appointments", "post">;
+// => { service_id: string; start_time: string; client: { ... }; ... }
+```
+
+## API Reference
+
+See the [SavvyCal Appointments API documentation](https://developers.savvycal.app) for full API details.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,527 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  cancelAppointment: () => cancelAppointment,
+  cancelPublicAppointment: () => cancelPublicAppointment,
+  confirmAppointment: () => confirmAppointment,
+  createAccount: () => createAccount,
+  createAccountUser: () => createAccountUser,
+  createAppointment: () => createAppointment,
+  createBlock: () => createBlock,
+  createCancellationReason: () => createCancellationReason,
+  createClient: () => createClient2,
+  createDashboardSession: () => createDashboardSession,
+  createFetchClient: () => createFetchClient,
+  createProvider: () => createProvider,
+  createProviderSchedule: () => createProviderSchedule,
+  createPublicAppointment: () => createPublicAppointment,
+  createService: () => createService,
+  createServiceProvider: () => createServiceProvider,
+  deactivateProvider: () => deactivateProvider,
+  deleteBlock: () => deleteBlock,
+  deleteCancellationReason: () => deleteCancellationReason,
+  deleteClient: () => deleteClient,
+  deleteProviderSchedule: () => deleteProviderSchedule,
+  deleteService: () => deleteService,
+  deleteServiceProvider: () => deleteServiceProvider,
+  getAccountById: () => getAccountById,
+  getAppointment: () => getAppointment,
+  getBlock: () => getBlock,
+  getCancellationReason: () => getCancellationReason,
+  getClient: () => getClient,
+  getCurrentAccount: () => getCurrentAccount,
+  getCurrentAccountUser: () => getCurrentAccountUser,
+  getCurrentPlatform: () => getCurrentPlatform,
+  getEarliestPublicServiceSlot: () => getEarliestPublicServiceSlot,
+  getProvider: () => getProvider,
+  getProviderSchedule: () => getProviderSchedule,
+  getPublicAppointment: () => getPublicAppointment,
+  getService: () => getService,
+  listAccountUsers: () => listAccountUsers,
+  listAccounts: () => listAccounts,
+  listAppointments: () => listAppointments,
+  listBlocks: () => listBlocks,
+  listCancellationReasons: () => listCancellationReasons,
+  listClients: () => listClients,
+  listProviderSchedules: () => listProviderSchedules,
+  listProviders: () => listProviders,
+  listPublicCancellationReasons: () => listPublicCancellationReasons,
+  listPublicServiceSlots: () => listPublicServiceSlots,
+  listRoles: () => listRoles,
+  listServiceProviders: () => listServiceProviders,
+  listServiceSlots: () => listServiceSlots,
+  listServices: () => listServices,
+  rescheduleAppointment: () => rescheduleAppointment,
+  reschedulePublicAppointment: () => reschedulePublicAppointment,
+  updateAccount: () => updateAccount,
+  updateBlock: () => updateBlock,
+  updateCancellationReason: () => updateCancellationReason,
+  updateClient: () => updateClient,
+  updateProvider: () => updateProvider,
+  updateProviderSchedule: () => updateProviderSchedule,
+  updateService: () => updateService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+var DEFAULT_BASE_URL = "https://api.savvycal.app";
+var UNPROTECTED_PATHS = ["/v1/public"];
+var isValidJwt = (token) => {
+  const parts = token.split(".");
+  if (parts.length !== 3) return false;
+  try {
+    JSON.parse(atob(parts[1]));
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isTokenExpired = (token) => {
+  try {
+    const payload = token.split(".")[1];
+    if (!payload) return true;
+    const decoded = JSON.parse(atob(payload));
+    if (!decoded.exp) return false;
+    return decoded.exp * 1e3 < Date.now();
+  } catch {
+    return true;
+  }
+};
+var createFetchClient = (options = {}) => {
+  let accessToken;
+  const authMiddleware = {
+    async onRequest({ request, schemaPath }) {
+      if (UNPROTECTED_PATHS.some((path) => schemaPath.startsWith(path))) {
+        return void 0;
+      }
+      if (options.demo) {
+        request.headers.set("Authorization", `Demo ${options.demo}`);
+        return request;
+      }
+      if (!options.fetchAccessToken) {
+        throw new Error("No fetchAccessToken provided");
+      }
+      if (!accessToken || isTokenExpired(accessToken)) {
+        const authRes = await options.fetchAccessToken();
+        if (!authRes) {
+          throw new Error("No access token");
+        }
+        if (!isValidJwt(authRes)) {
+          throw new Error("Invalid access token: expected a JWT");
+        }
+        accessToken = authRes;
+      }
+      request.headers.set("Authorization", `Bearer ${accessToken}`);
+      return request;
+    }
+  };
+  const clientOptions = {
+    baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+    headers: {},
+    ...options
+  };
+  if (options.demo) {
+    clientOptions.headers = {
+      ...clientOptions.headers,
+      Authorization: `Demo ${options.demo}`
+    };
+  }
+  if (options.account) {
+    clientOptions.headers = {
+      ...clientOptions.headers,
+      "X-SavvyCal-Account": options.account
+    };
+  }
+  const client = (0, import_openapi_fetch.default)(clientOptions);
+  client.use(authMiddleware);
+  return client;
+};
+
+// src/operations.ts
+function cancelAppointment(client, path, body) {
+  return client.POST("/v1/appointments/{appointment_id}/cancel", {
+    body,
+    params: { path }
+  });
+}
+function cancelPublicAppointment(client, path, body) {
+  return client.POST("/v1/public/appointments/{appointment_id}/cancel", {
+    body,
+    params: { path }
+  });
+}
+function confirmAppointment(client, path, body) {
+  return client.POST("/v1/appointments/{appointment_id}/confirm", {
+    body,
+    params: { path }
+  });
+}
+function createAccount(client, body) {
+  return client.POST("/v1/accounts", {
+    body
+  });
+}
+function createAccountUser(client, body) {
+  return client.POST("/v1/users", {
+    body
+  });
+}
+function createAppointment(client, body) {
+  return client.POST("/v1/appointments", {
+    body
+  });
+}
+function createBlock(client, body) {
+  return client.POST("/v1/blocks", {
+    body
+  });
+}
+function createCancellationReason(client, body) {
+  return client.POST("/v1/cancellation_reasons", {
+    body
+  });
+}
+function createClient2(client, body) {
+  return client.POST("/v1/clients", {
+    body
+  });
+}
+function createDashboardSession(client, body) {
+  return client.POST("/v1/dashboard_sessions", {
+    body
+  });
+}
+function createProvider(client, body) {
+  return client.POST("/v1/providers", {
+    body
+  });
+}
+function createProviderSchedule(client, path, body) {
+  return client.POST("/v1/providers/{provider_id}/schedules", {
+    body,
+    params: { path }
+  });
+}
+function createPublicAppointment(client, body) {
+  return client.POST("/v1/public/appointments", {
+    body
+  });
+}
+function createService(client, body) {
+  return client.POST("/v1/services", {
+    body
+  });
+}
+function createServiceProvider(client, path, body) {
+  return client.POST("/v1/services/{service_id}/providers", {
+    body,
+    params: { path }
+  });
+}
+function deactivateProvider(client, path) {
+  return client.DELETE("/v1/providers/{provider_id}", {
+    params: { path }
+  });
+}
+function deleteBlock(client, path) {
+  return client.DELETE("/v1/blocks/{block_id}", {
+    params: { path }
+  });
+}
+function deleteCancellationReason(client, path) {
+  return client.DELETE("/v1/cancellation_reasons/{cancellation_reason_id}", {
+    params: { path }
+  });
+}
+function deleteClient(client, path) {
+  return client.DELETE("/v1/clients/{client_id}", {
+    params: { path }
+  });
+}
+function deleteProviderSchedule(client, path) {
+  return client.DELETE("/v1/provider_schedules/{provider_schedule_id}", {
+    params: { path }
+  });
+}
+function deleteService(client, path) {
+  return client.DELETE("/v1/services/{service_id}", {
+    params: { path }
+  });
+}
+function deleteServiceProvider(client, path) {
+  return client.DELETE("/v1/service_providers/{service_provider_id}", {
+    params: { path }
+  });
+}
+function getAccountById(client, path) {
+  return client.GET("/v1/accounts/{account_id}", {
+    params: { path }
+  });
+}
+function getAppointment(client, path, query) {
+  return client.GET("/v1/appointments/{appointment_id}", {
+    params: { path, query }
+  });
+}
+function getBlock(client, path) {
+  return client.GET("/v1/blocks/{block_id}", {
+    params: { path }
+  });
+}
+function getCancellationReason(client, path) {
+  return client.GET("/v1/cancellation_reasons/{cancellation_reason_id}", {
+    params: { path }
+  });
+}
+function getClient(client, path) {
+  return client.GET("/v1/clients/{client_id}", {
+    params: { path }
+  });
+}
+function getCurrentAccount(client) {
+  return client.GET("/v1/account");
+}
+function getCurrentAccountUser(client) {
+  return client.GET("/v1/user");
+}
+function getCurrentPlatform(client) {
+  return client.GET("/v1/platform");
+}
+function getEarliestPublicServiceSlot(client, path, query) {
+  return client.GET("/v1/public/services/{service_id}/earliest_slot", {
+    params: { path, query }
+  });
+}
+function getProvider(client, path) {
+  return client.GET("/v1/providers/{provider_id}", {
+    params: { path }
+  });
+}
+function getProviderSchedule(client, path) {
+  return client.GET("/v1/provider_schedules/{provider_schedule_id}", {
+    params: { path }
+  });
+}
+function getPublicAppointment(client, path) {
+  return client.GET("/v1/public/appointments/{appointment_id}", {
+    params: { path }
+  });
+}
+function getService(client, path) {
+  return client.GET("/v1/services/{service_id}", {
+    params: { path }
+  });
+}
+function listAccounts(client, query) {
+  return client.GET("/v1/accounts", {
+    params: { query }
+  });
+}
+function listAccountUsers(client) {
+  return client.GET("/v1/users");
+}
+function listAppointments(client, query) {
+  return client.GET("/v1/appointments", {
+    params: { query }
+  });
+}
+function listBlocks(client, query) {
+  return client.GET("/v1/blocks", {
+    params: { query }
+  });
+}
+function listCancellationReasons(client) {
+  return client.GET("/v1/cancellation_reasons");
+}
+function listClients(client, query) {
+  return client.GET("/v1/clients", {
+    params: { query }
+  });
+}
+function listProviders(client, query) {
+  return client.GET("/v1/providers", {
+    params: { query }
+  });
+}
+function listProviderSchedules(client, query) {
+  return client.GET("/v1/provider_schedules", {
+    params: { query }
+  });
+}
+function listPublicCancellationReasons(client, path) {
+  return client.GET(
+    "/v1/public/appointments/{appointment_id}/cancellation_reasons",
+    {
+      params: { path }
+    }
+  );
+}
+function listPublicServiceSlots(client, path, query) {
+  return client.GET("/v1/public/services/{service_id}/slots", {
+    params: { path, query }
+  });
+}
+function listRoles(client) {
+  return client.GET("/v1/roles");
+}
+function listServiceProviders(client, path) {
+  return client.GET("/v1/services/{service_id}/providers", {
+    params: { path }
+  });
+}
+function listServices(client, query) {
+  return client.GET("/v1/services", {
+    params: { query }
+  });
+}
+function listServiceSlots(client, path, query) {
+  return client.GET("/v1/services/{service_id}/slots", {
+    params: { path, query }
+  });
+}
+function rescheduleAppointment(client, path, body) {
+  return client.POST("/v1/appointments/{appointment_id}/reschedule", {
+    body,
+    params: { path }
+  });
+}
+function reschedulePublicAppointment(client, path, body) {
+  return client.POST("/v1/public/appointments/{appointment_id}/reschedule", {
+    body,
+    params: { path }
+  });
+}
+function updateAccount(client, path, body) {
+  return client.PATCH("/v1/accounts/{account_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateBlock(client, path, body) {
+  return client.PATCH("/v1/blocks/{block_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateCancellationReason(client, path, body) {
+  return client.PATCH("/v1/cancellation_reasons/{cancellation_reason_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateClient(client, path, body) {
+  return client.PATCH("/v1/clients/{client_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateProvider(client, path, body) {
+  return client.PATCH("/v1/providers/{provider_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateProviderSchedule(client, path, body) {
+  return client.PATCH("/v1/provider_schedules/{provider_schedule_id}", {
+    body,
+    params: { path }
+  });
+}
+function updateService(client, path, body) {
+  return client.PATCH("/v1/services/{service_id}", {
+    body,
+    params: { path }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cancelAppointment,
+  cancelPublicAppointment,
+  confirmAppointment,
+  createAccount,
+  createAccountUser,
+  createAppointment,
+  createBlock,
+  createCancellationReason,
+  createClient,
+  createDashboardSession,
+  createFetchClient,
+  createProvider,
+  createProviderSchedule,
+  createPublicAppointment,
+  createService,
+  createServiceProvider,
+  deactivateProvider,
+  deleteBlock,
+  deleteCancellationReason,
+  deleteClient,
+  deleteProviderSchedule,
+  deleteService,
+  deleteServiceProvider,
+  getAccountById,
+  getAppointment,
+  getBlock,
+  getCancellationReason,
+  getClient,
+  getCurrentAccount,
+  getCurrentAccountUser,
+  getCurrentPlatform,
+  getEarliestPublicServiceSlot,
+  getProvider,
+  getProviderSchedule,
+  getPublicAppointment,
+  getService,
+  listAccountUsers,
+  listAccounts,
+  listAppointments,
+  listBlocks,
+  listCancellationReasons,
+  listClients,
+  listProviderSchedules,
+  listProviders,
+  listPublicCancellationReasons,
+  listPublicServiceSlots,
+  listRoles,
+  listServiceProviders,
+  listServiceSlots,
+  listServices,
+  rescheduleAppointment,
+  reschedulePublicAppointment,
+  updateAccount,
+  updateBlock,
+  updateCancellationReason,
+  updateClient,
+  updateProvider,
+  updateProviderSchedule,
+  updateService
+});