@bulutklinik/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,647 @@
+'use strict';
+
+// src/token-store.ts
+var MemoryTokenStore = class {
+  #access;
+  #refresh;
+  constructor(seed) {
+    this.#access = seed?.accessToken ?? null;
+    this.#refresh = seed?.refreshToken ?? null;
+  }
+  getAccessToken() {
+    return this.#access;
+  }
+  getRefreshToken() {
+    return this.#refresh;
+  }
+  setTokens(accessToken, refreshToken) {
+    this.#access = accessToken;
+    this.#refresh = refreshToken;
+  }
+  clear() {
+    this.#access = null;
+    this.#refresh = null;
+  }
+};
+
+// src/config.ts
+var ENVIRONMENT_BASE_URLS = {
+  production: "https://api.bulutklinik.com/api/v3",
+  test: "https://apitest.bulutklinik.com/api/v3",
+  local: "https://api-bulutklinik.test/api/v3"
+};
+function resolveConfig(options = {}) {
+  const base = options.baseUrl ?? ENVIRONMENT_BASE_URLS[options.environment ?? "production"];
+  const fetchImpl = options.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  if (typeof fetchImpl !== "function") {
+    throw new Error(
+      "No fetch implementation available. Provide options.fetch or run on Node >= 18."
+    );
+  }
+  return {
+    baseUrl: base.replace(/\/+$/, ""),
+    lang: options.lang ?? "tr",
+    clientId: options.clientId,
+    clientSecret: options.clientSecret,
+    partnerToken: options.partnerToken,
+    tokenStore: options.tokenStore ?? new MemoryTokenStore(),
+    timeoutMs: options.timeoutMs ?? 3e4,
+    fetchImpl
+  };
+}
+
+// src/errors.ts
+var BulutklinikError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var TransportError = class extends BulutklinikError {
+  constructor(message, cause) {
+    super(message, { cause });
+  }
+};
+var ApiError = class extends BulutklinikError {
+  httpStatus;
+  resultType;
+  errorType;
+  data;
+  method;
+  path;
+  constructor(message, ctx) {
+    super(message);
+    this.httpStatus = ctx.httpStatus;
+    this.resultType = ctx.resultType;
+    this.errorType = ctx.errorType;
+    this.data = ctx.data;
+    this.method = ctx.method;
+    this.path = ctx.path;
+  }
+};
+var ValidationError = class extends ApiError {
+};
+var AuthenticationError = class extends ApiError {
+};
+var AuthorizationError = class extends ApiError {
+};
+var NotFoundError = class extends ApiError {
+};
+var RateLimitError = class extends ApiError {
+  retryAfter;
+  constructor(message, ctx) {
+    super(message, ctx);
+    this.retryAfter = ctx.retryAfter;
+  }
+};
+function createApiError(ctx, message) {
+  if (ctx.resultType === 2) return new AuthenticationError(message, ctx);
+  const type = typeof ctx.errorType === "string" ? ctx.errorType.toLowerCase() : void 0;
+  if (type === "validation" || ctx.httpStatus === 422) {
+    return new ValidationError(message, ctx);
+  }
+  switch (ctx.httpStatus) {
+    case 401:
+      return new AuthenticationError(message, ctx);
+    case 403:
+      return new AuthorizationError(message, ctx);
+    case 404:
+      return new NotFoundError(message, ctx);
+    case 429:
+      return new RateLimitError(message, ctx);
+    default:
+      return new ApiError(message, ctx);
+  }
+}
+
+// src/types.ts
+var ResultType = {
+  Success: 0,
+  Error: 1,
+  Logout: 2,
+  Update: 3,
+  Refresh: 4
+};
+
+// src/http.ts
+var HttpClient = class {
+  tokenStore;
+  clientId;
+  clientSecret;
+  baseUrl;
+  lang;
+  partnerToken;
+  timeoutMs;
+  fetchImpl;
+  refreshInFlight = null;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.lang = config.lang;
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    this.partnerToken = config.partnerToken;
+    this.tokenStore = config.tokenStore;
+    this.timeoutMs = config.timeoutMs;
+    this.fetchImpl = config.fetchImpl;
+  }
+  request(spec) {
+    return this.send(spec, false);
+  }
+  /** Force a token refresh using the stored refresh token. Throws on failure. */
+  async refresh() {
+    await this.performRefresh();
+  }
+  async send(spec, isRetry) {
+    const response = await this.dispatch(spec);
+    const envelope = await this.readEnvelope(response);
+    if (response.ok && envelope.resultType === ResultType.Success) {
+      return envelope.data;
+    }
+    const expired = response.status === 401 || envelope.resultType === ResultType.Refresh;
+    if (spec.auth === "bearer" && expired && !isRetry) {
+      const refreshed = await this.ensureRefreshed();
+      if (refreshed) {
+        return this.send(spec, true);
+      }
+    }
+    if (envelope.resultType === ResultType.Logout) {
+      await this.tokenStore.clear();
+    }
+    throw this.toError(spec, response, envelope);
+  }
+  async dispatch(spec) {
+    const url = this.baseUrl + spec.path;
+    const headers = {
+      Accept: "application/json",
+      lang: spec.lang ?? this.lang
+    };
+    const hasBody = spec.body !== void 0 && spec.method !== "GET";
+    if (hasBody) headers["Content-Type"] = "application/json";
+    if (spec.auth === "bearer") {
+      const token = await this.tokenStore.getAccessToken();
+      if (token) headers.Authorization = `Bearer ${token}`;
+    } else if (spec.auth === "partner") {
+      if (this.partnerToken) headers.Authorization = `Bearer ${this.partnerToken}`;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, {
+        method: spec.method,
+        headers,
+        body: hasBody ? JSON.stringify(spec.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new TransportError(
+          `Request ${spec.method} ${spec.path} timed out after ${this.timeoutMs}ms`,
+          error
+        );
+      }
+      throw new TransportError(`Network error on ${spec.method} ${spec.path}`, error);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async readEnvelope(response) {
+    const text = await response.text();
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { errorMessage: text };
+    }
+  }
+  async ensureRefreshed() {
+    if (!this.refreshInFlight) {
+      this.refreshInFlight = this.performRefresh().finally(() => {
+        this.refreshInFlight = null;
+      });
+    }
+    try {
+      await this.refreshInFlight;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async performRefresh() {
+    const refreshToken = await this.tokenStore.getRefreshToken();
+    if (!refreshToken) throw new Error("No refresh token available");
+    if (!this.clientId || !this.clientSecret) {
+      throw new Error("clientId and clientSecret are required to refresh tokens");
+    }
+    const response = await this.dispatch({
+      method: "POST",
+      path: "/general/refreshApi",
+      auth: "public",
+      body: { refreshToken, clientId: this.clientId, clientSecretKey: this.clientSecret }
+    });
+    const envelope = await this.readEnvelope(response);
+    const data = envelope.data;
+    if (!response.ok || envelope.resultType !== ResultType.Success || !data?.access_token) {
+      await this.tokenStore.clear();
+      throw new Error("Token refresh failed");
+    }
+    await this.tokenStore.setTokens(data.access_token, data.refresh_token ?? refreshToken);
+  }
+  toError(spec, response, envelope) {
+    const retryAfterHeader = response.headers.get("retry-after");
+    const ctx = {
+      httpStatus: response.status,
+      resultType: envelope.resultType,
+      errorType: envelope.errorType,
+      data: envelope.data,
+      method: spec.method,
+      path: spec.path,
+      retryAfter: retryAfterHeader ? Number(retryAfterHeader) : void 0
+    };
+    const message = envelope.errorMessage ?? `Bulutklinik API request failed: ${spec.method} ${spec.path} (HTTP ${response.status})`;
+    return createApiError(ctx, message);
+  }
+};
+
+// src/resources/appointments.ts
+var AppointmentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Reserve an online (interview) slot. Resolves to `null` on success. */
+  reserveInterview(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/addInterviewDateReservation",
+      auth: "bearer",
+      body: {
+        doctorId: input.doctorId,
+        appointmentDate: input.appointmentDate,
+        appointmentType: input.appointmentType ?? "interview"
+      }
+    });
+  }
+  /** Create a physical appointment. */
+  addPhysical(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/addNewAppointment",
+      auth: "bearer",
+      body: { doctorId: input.doctorId, appointmentDate: input.appointmentDate }
+    });
+  }
+  /** Cancel an appointment by event id (`cln_events.id`). */
+  cancel(eventId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/patients/deleteUserAppointment/${eventId}`,
+      auth: "bearer"
+    });
+  }
+};
+
+// src/resources/auth.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Log in. On success tokens are stored automatically and
+   * `{ twoFactorRequired: false }` is returned. If 2FA is enabled the result is
+   * `{ twoFactorRequired: true, twoFactorResponse }` — pass that blob to
+   * {@link connectWithTwoFactor} together with the SMS code.
+   */
+  async connect(input) {
+    const data = await this.http.request({
+      method: "POST",
+      path: "/general/connectApi",
+      auth: "public",
+      body: {
+        apiUserName: input.apiUserName,
+        apiUserPassword: input.apiUserPassword,
+        apiClientId: input.clientId ?? this.http.clientId,
+        apiSecretKey: input.clientSecret ?? this.http.clientSecret,
+        loginMode: input.loginMode,
+        ...input.withPhoneNumber !== void 0 ? { withPhoneNumber: input.withPhoneNumber } : {}
+      }
+    });
+    if (data.access_token) {
+      await this.storeTokens(data);
+      return { twoFactorRequired: false, passwordPolicy: data.password_policy };
+    }
+    if (data.response) {
+      return { twoFactorRequired: true, twoFactorResponse: data.response };
+    }
+    return { twoFactorRequired: false };
+  }
+  /** Complete a 2FA login with the SMS code and the challenge blob. */
+  async connectWithTwoFactor(input) {
+    const data = await this.http.request({
+      method: "POST",
+      path: "/general/connectApiWithTwoFactor",
+      auth: "public",
+      body: { smsVerificationCode: input.smsVerificationCode, response: input.response }
+    });
+    await this.storeTokens(data);
+  }
+  /** Register a new patient (afterRegister auto-login). Stores tokens on success. */
+  async register(input) {
+    const data = await this.http.request({
+      method: "POST",
+      path: "/patients/addNewPatient",
+      auth: "public",
+      body: {
+        name: input.name,
+        surname: input.surname,
+        apiUserName: input.apiUserName,
+        phoneNumber: input.phoneNumber,
+        password: input.password,
+        smsVerificationCode: input.smsVerificationCode,
+        response: input.response,
+        acceptUserAgreement: input.acceptUserAgreement ?? 1,
+        apiClientId: input.clientId ?? this.http.clientId,
+        apiSecretKey: input.clientSecret ?? this.http.clientSecret
+      }
+    });
+    await this.storeTokens(data);
+  }
+  /** Manually refresh the access token using the stored refresh token. */
+  refresh() {
+    return this.http.refresh();
+  }
+  /** Revoke the current tokens server-side and clear the local token store. */
+  async disconnect() {
+    try {
+      await this.http.request({
+        method: "POST",
+        path: "/general/disconnectApi",
+        auth: "bearer",
+        body: {}
+      });
+    } finally {
+      await this.http.tokenStore.clear();
+    }
+  }
+  async storeTokens(data) {
+    if (!data.access_token) {
+      throw new Error("Login response did not contain an access token");
+    }
+    await this.http.tokenStore.setTokens(data.access_token, data.refresh_token ?? null);
+  }
+};
+
+// src/resources/doctors.ts
+var DoctorsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  branches() {
+    return this.http.request({
+      method: "GET",
+      path: "/patients/allBranches",
+      auth: "bearer"
+    });
+  }
+  locations() {
+    return this.http.request({
+      method: "GET",
+      path: "/patients/allLocations",
+      auth: "bearer"
+    });
+  }
+  quickSearch(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/quickSearch",
+      auth: "bearer",
+      body: {
+        searchText: input.searchText,
+        listType: input.listType ?? null,
+        location: input.location ?? null
+      }
+    });
+  }
+  search(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/filteredSearch",
+      auth: "bearer",
+      body: {
+        searchParams: input.searchParams ?? {},
+        orderParams: input.orderParams ?? [],
+        otherParams: input.otherParams ?? [],
+        currentPage: input.currentPage,
+        perPageLimit: input.perPageLimit ?? 20
+      }
+    });
+  }
+  detail(id, corporate) {
+    const path = corporate !== void 0 ? `/patients/doctorDetail/${id}/${corporate}` : `/patients/doctorDetail/${id}`;
+    return this.http.request({ method: "GET", path, auth: "bearer" });
+  }
+};
+
+// src/resources/measures.ts
+var MeasuresResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Submit multiple measurements of any types in one call (primary entrypoint). */
+  addList(records) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/addNewUserMeasures",
+      auth: "bearer",
+      body: { data: records }
+    });
+  }
+  /** Submit a single measurement of one type. */
+  add(type, fields) {
+    return this.http.request({
+      method: "POST",
+      path: `/patients/addNewUserMeasures/${type}`,
+      auth: "bearer",
+      body: fields
+    });
+  }
+  update(type, input) {
+    return this.http.request({
+      method: "PUT",
+      path: `/patients/updateUserMeasures/${type}`,
+      auth: "bearer",
+      body: input
+    });
+  }
+  delete(type, id) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/patients/deleteUserMeasures/${type}`,
+      auth: "bearer",
+      body: { id }
+    });
+  }
+  /** Latest value of each measurement type. */
+  last() {
+    return this.http.request({
+      method: "GET",
+      path: "/patients/measuresList",
+      auth: "bearer"
+    });
+  }
+  /** Paginated history for one type. `glucoseType` (0/1) applies only to glucose. */
+  list(type, page, glucoseType) {
+    const path = glucoseType !== void 0 ? `/patients/userMeasuresList/${type}/${page}/${glucoseType}` : `/patients/userMeasuresList/${type}/${page}`;
+    return this.http.request({ method: "GET", path, auth: "bearer" });
+  }
+  /** Grouped graph data. `period`: 1=day, 2=week, 3=month, 4=year. */
+  graph(type, period, page, glucoseType) {
+    const path = glucoseType !== void 0 ? `/patients/userMeasuresGraph/${type}/${period}/${page}/${glucoseType}` : `/patients/userMeasuresGraph/${type}/${period}/${page}`;
+    return this.http.request({ method: "GET", path, auth: "bearer" });
+  }
+  /** Partner (teusan) submission — uses the configured partner token. */
+  partnerHealthInformation(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/outher/healthInformation",
+      auth: "partner",
+      body: { identity: input.identity, phoneNumber: input.phoneNumber, data: input.data }
+    });
+  }
+};
+
+// src/resources/payments.ts
+var PaymentsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Validate a discount code. Note: this endpoint lives under the `patients` prefix. */
+  checkDiscountCode(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/checkDiscountCode",
+      auth: "bearer",
+      body: { ...input }
+    });
+  }
+  getCards() {
+    return this.http.request({
+      method: "GET",
+      path: "/payments/getCards",
+      auth: "bearer"
+    });
+  }
+  saveCard(card) {
+    return this.http.request({
+      method: "POST",
+      path: "/payments/saveCard",
+      auth: "bearer",
+      body: { ...card }
+    });
+  }
+  /**
+   * Start an appointment payment. The amount is computed server-side. On a 3DS
+   * flow the result carries `payment3DUrl` — a browser URL to open; the SDK does
+   * not follow it. 3DS capture happens via the bank → server callback.
+   */
+  pay(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/payments/interviewPayment",
+      auth: "bearer",
+      body: {
+        doctorId: input.doctorId,
+        appointmentDate: input.appointmentDate,
+        appointmentType: input.appointmentType ?? "interview",
+        is3D: input.is3D,
+        termsAccept: input.termsAccept,
+        saveCard: input.saveCard ?? 0,
+        discountCode: input.discountCode ?? "",
+        ...input.cardId !== void 0 ? { cardId: input.cardId } : {},
+        ...input.cardInfo ? { cardInfo: input.cardInfo } : {},
+        ...input.caseDetail ? { caseDetail: input.caseDetail } : {}
+      }
+    });
+  }
+  deleteCard(cardId) {
+    return this.http.request({
+      method: "DELETE",
+      path: `/payments/deleteCard/${cardId}`,
+      auth: "bearer"
+    });
+  }
+};
+
+// src/resources/slots.ts
+var SlotsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Fetch a doctor's free slots. Returns a date-keyed map of slots. Build the
+   * next step's `appointmentDate` as `"<date> <slotStart>"` (drop the seconds).
+   */
+  schedule(input) {
+    return this.http.request({
+      method: "POST",
+      path: "/patients/doctorScheduler",
+      auth: "bearer",
+      body: {
+        doctorId: input.doctorId,
+        scheduleDate: input.scheduleDate ?? null,
+        scheduleStep: input.scheduleStep ?? "7",
+        schedulePage: input.schedulePage ?? "1",
+        listType: input.listType
+      }
+    });
+  }
+};
+
+// src/client.ts
+var BulutklinikClient = class {
+  auth;
+  doctors;
+  slots;
+  appointments;
+  payments;
+  measures;
+  /** The active token store (also accepts a custom one via options). */
+  tokenStore;
+  http;
+  constructor(options) {
+    const config = resolveConfig(options);
+    this.http = new HttpClient(config);
+    this.tokenStore = config.tokenStore;
+    this.auth = new AuthResource(this.http);
+    this.doctors = new DoctorsResource(this.http);
+    this.slots = new SlotsResource(this.http);
+    this.appointments = new AppointmentsResource(this.http);
+    this.payments = new PaymentsResource(this.http);
+    this.measures = new MeasuresResource(this.http);
+  }
+};
+
+exports.ApiError = ApiError;
+exports.AppointmentsResource = AppointmentsResource;
+exports.AuthResource = AuthResource;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.BulutklinikClient = BulutklinikClient;
+exports.BulutklinikError = BulutklinikError;
+exports.DoctorsResource = DoctorsResource;
+exports.ENVIRONMENT_BASE_URLS = ENVIRONMENT_BASE_URLS;
+exports.MeasuresResource = MeasuresResource;
+exports.MemoryTokenStore = MemoryTokenStore;
+exports.NotFoundError = NotFoundError;
+exports.PaymentsResource = PaymentsResource;
+exports.RateLimitError = RateLimitError;
+exports.ResultType = ResultType;
+exports.SlotsResource = SlotsResource;
+exports.TransportError = TransportError;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map