routesync 1.0.0

package/dist/sdk.js

@@ -0,0 +1,519 @@
+"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);
+
+// packages/sdk/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GenericService: () => GenericService,
+  camelToSnakeKey: () => camelToSnakeKey,
+  createClient: () => createClient,
+  createHttpClient: () => createClient2,
+  createService: () => createService,
+  defineApi: () => defineApi,
+  endpoint: () => endpoint,
+  generateHooks: () => generateHooks,
+  mapKeysDeep: () => mapKeysDeep,
+  parseWithSchema: () => parseWithSchema,
+  resource: () => resource,
+  snakeToCamelKey: () => snakeToCamelKey,
+  toCamelCase: () => toCamelCase,
+  toSnakeCase: () => toSnakeCase
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/core/src/client/HttpClient.ts
+var import_axios = __toESM(require("axios"));
+var HttpClient = class {
+  constructor(config) {
+    this.client = import_axios.default.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout ?? 1e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers ?? {}
+      }
+    });
+    if (config.token) {
+      this.setToken(config.token);
+    }
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        const message = error.response?.data?.message ?? error.message ?? "Unknown error";
+        return Promise.reject({
+          success: false,
+          message,
+          status: error.response?.status,
+          errors: error.response?.data?.errors
+        });
+      }
+    );
+  }
+  setToken(token) {
+    this.client.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+  }
+  removeToken() {
+    delete this.client.defaults.headers.common["Authorization"];
+  }
+  async get(url, config) {
+    const response = await this.client.get(url, config);
+    return response.data;
+  }
+  async post(url, body, config) {
+    const response = await this.client.post(url, body, config);
+    return response.data;
+  }
+  async put(url, body, config) {
+    const response = await this.client.put(url, body, config);
+    return response.data;
+  }
+  async patch(url, body, config) {
+    const response = await this.client.patch(url, body, config);
+    return response.data;
+  }
+  async delete(url, config) {
+    const response = await this.client.delete(url, config);
+    return response.data;
+  }
+  async upload(url, formData) {
+    const response = await this.client.post(url, formData, {
+      headers: { "Content-Type": "multipart/form-data" }
+    });
+    return response.data;
+  }
+  getInstance() {
+    return this.client;
+  }
+};
+
+// packages/core/src/auth/TokenManager.ts
+var _TokenManager = class _TokenManager {
+  constructor() {
+    this.token = null;
+  }
+  set(token) {
+    this.token = token;
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(_TokenManager.TOKEN_KEY, token);
+    }
+  }
+  get() {
+    if (this.token) return this.token;
+    if (typeof localStorage !== "undefined") {
+      return localStorage.getItem(_TokenManager.TOKEN_KEY);
+    }
+    return null;
+  }
+  clear() {
+    this.token = null;
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(_TokenManager.TOKEN_KEY);
+    }
+  }
+  exists() {
+    return this.get() !== null;
+  }
+};
+_TokenManager.TOKEN_KEY = "routesync_token";
+var TokenManager = _TokenManager;
+
+// packages/core/src/routing/PathResolver.ts
+var PathResolver = class {
+  /**
+   * Resolve path params.
+   * e.g. resolvePath('/produk/:id', { id: 10 }) => '/produk/10'
+   */
+  static resolve(path, params) {
+    if (!params) return path;
+    let resolved = path;
+    for (const [key, value] of Object.entries(params)) {
+      resolved = resolved.replace(`:${key}`, String(value));
+    }
+    const unresolved = resolved.match(/:([a-zA-Z_]+)/g);
+    if (unresolved) {
+      throw new Error(
+        `Unresolved path params: ${unresolved.join(", ")}`
+      );
+    }
+    return resolved;
+  }
+  static extractParams(path) {
+    const matches = path.match(/:([a-zA-Z_]+)/g) ?? [];
+    return matches.map((m) => m.slice(1));
+  }
+  static hasParams(path) {
+    return /:([a-zA-Z_]+)/.test(path);
+  }
+};
+
+// packages/sdk/src/mappers/schema.ts
+function parseWithSchema(schema, value) {
+  if (!schema) return value;
+  if (typeof schema === "function") {
+    return schema(value);
+  }
+  if (schema.safeParse) {
+    const result = schema.safeParse(value);
+    if (result.success) return result.data;
+    throw result.error;
+  }
+  if (schema.parse) {
+    return schema.parse(value);
+  }
+  return value;
+}
+
+// packages/sdk/src/defineApi.ts
+var _client = null;
+function getClient() {
+  if (!_client) {
+    throw new Error("RouteSync not initialized. Call createClient() first.");
+  }
+  return _client;
+}
+function createClient(config) {
+  _client = new HttpClient(config);
+  return _client;
+}
+function defineApi(definition, config) {
+  if (config) {
+    createClient(config);
+  }
+  const proxy = {};
+  for (const group in definition) {
+    const groupDef = definition[group];
+    const groupProxy = {};
+    for (const action in groupDef) {
+      const route = groupDef[action];
+      const callable = async (options) => {
+        const client = getClient();
+        const params = applyMapper(
+          route,
+          "params",
+          parseRouteSchema(route, "params", options?.params)
+        );
+        const query = applyMapper(
+          route,
+          "query",
+          parseRouteSchema(route, "query", options?.query)
+        );
+        const body = applyMapper(
+          route,
+          "body",
+          parseRouteSchema(route, "body", options?.body)
+        );
+        const resolvedPath = PathResolver.resolve(route.path, params);
+        const method = route.method.toLowerCase();
+        const requestConfig = { params: query, headers: route.headers };
+        let response;
+        if (method === "get" || method === "delete") {
+          response = await client[method](resolvedPath, requestConfig);
+        } else {
+          response = await client[method](resolvedPath, body, requestConfig);
+        }
+        return applyMapper(
+          route,
+          "response",
+          parseRouteSchema(route, "response", response)
+        );
+      };
+      callable.$def = route;
+      callable.$key = [group, action];
+      groupProxy[action] = callable;
+    }
+    ;
+    proxy[group] = groupProxy;
+  }
+  return proxy;
+}
+var routeSchemaKeys = ["params", "query", "body", "request", "response"];
+function parseRouteSchema(route, part, value) {
+  if (value === void 0) return void 0;
+  const schema = pickRouteSchema(route, part);
+  return parseWithSchema(schema, value);
+}
+function pickRouteSchema(route, part) {
+  const schema = route.schema;
+  if (!schema) return void 0;
+  if (hasRouteSchemaKeys(schema)) {
+    return schema[part] ?? (part === "body" ? schema.request : void 0);
+  }
+  return defaultSchemaPart(route.method) === part ? schema : void 0;
+}
+function hasRouteSchemaKeys(value) {
+  return Boolean(
+    value && typeof value === "object" && routeSchemaKeys.some((key) => key in value)
+  );
+}
+function defaultSchemaPart(method) {
+  return method === "GET" || method === "DELETE" ? "response" : "body";
+}
+function applyMapper(route, part, value) {
+  if (value === void 0 || !route.mapper) return value;
+  if (typeof route.mapper === "function") {
+    return part === "response" ? route.mapper(value) : value;
+  }
+  const mapper = route.mapper[part] ?? (part === "body" ? route.mapper.request : void 0);
+  return mapper ? mapper(value) : value;
+}
+
+// packages/sdk/src/endpoint.ts
+function endpoint(def) {
+  return def;
+}
+
+// packages/sdk/src/resource.ts
+function resource(config) {
+  const result = {};
+  for (const key in config.endpoints) {
+    const ep = config.endpoints[key];
+    result[key] = {
+      ...ep,
+      // Endpoint-level overrides cascade defaults, never the other way around
+      auth: ep.auth ?? config.auth,
+      headers: {
+        ...config.headers ?? {},
+        ...ep.headers ?? {}
+      },
+      cache: ep.cache ?? config.cache,
+      retry: ep.retry ?? config.retry
+    };
+  }
+  return result;
+}
+
+// packages/sdk/src/mappers/case.ts
+function snakeToCamelKey(key) {
+  return key.replace(/_([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+}
+function camelToSnakeKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function mapKeysDeep(value, keyCase) {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapKeysDeep(item, keyCase));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const mapper = keyCase === "camel" ? snakeToCamelKey : camelToSnakeKey;
+  const mapped = {};
+  for (const [key, child] of Object.entries(value)) {
+    mapped[mapper(key)] = mapKeysDeep(child, keyCase);
+  }
+  return mapped;
+}
+function toCamelCase(value) {
+  return mapKeysDeep(value, "camel");
+}
+function toSnakeCase(value) {
+  return mapKeysDeep(value, "snake");
+}
+
+// packages/sdk/src/createService.ts
+var GenericService = class {
+  constructor(client, endpoint2, options = {}) {
+    this.client = client;
+    this.endpoint = endpoint2;
+    this.options = options;
+  }
+  async findAll(params) {
+    const response = await this.client.get(this.endpoint, {
+      params: this.mapRequest(params)
+    });
+    const items = parseWithSchema(this.options.listSchema, this.extractData(response));
+    return items.map((item) => this.mapEntity(item));
+  }
+  async findById(id, params) {
+    const response = await this.client.get(`${this.endpoint}/${id}`, {
+      params: this.mapRequest(params)
+    });
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async create(payload) {
+    const validated = parseWithSchema(this.options.createSchema, payload);
+    const response = await this.client.post(this.endpoint, this.mapRequest(validated));
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async update(id, payload) {
+    const validated = parseWithSchema(this.options.updateSchema, payload);
+    const response = await this.client.put(
+      `${this.endpoint}/${id}`,
+      this.mapRequest(validated)
+    );
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async patch(id, payload) {
+    const validated = parseWithSchema(this.options.updateSchema, payload);
+    const response = await this.client.patch(
+      `${this.endpoint}/${id}`,
+      this.mapRequest(validated)
+    );
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  async delete(id) {
+    const response = await this.client.delete(`${this.endpoint}/${id}`);
+    return this.extractData(response);
+  }
+  async upload(file) {
+    const response = await this.client.upload(`${this.endpoint}/upload`, file);
+    return this.mapEntity(this.parseEntity(this.extractData(response)));
+  }
+  extractData(response) {
+    if (response && typeof response === "object" && "data" in response) {
+      return response.data;
+    }
+    return response;
+  }
+  parseEntity(value) {
+    return parseWithSchema(this.options.entitySchema, value);
+  }
+  mapEntity(value) {
+    if (this.options.fromBackend) {
+      return this.options.fromBackend(value);
+    }
+    if (this.options.mapResponseKeys === false) {
+      return value;
+    }
+    return toCamelCase(value);
+  }
+  mapRequest(value) {
+    if (value === void 0) return void 0;
+    if (this.options.toBackend) {
+      return this.options.toBackend(value);
+    }
+    if (this.options.mapRequestKeys === false) {
+      return value;
+    }
+    return toSnakeCase(value);
+  }
+};
+function createService(client, endpoint2, options) {
+  return new GenericService(
+    client,
+    endpoint2,
+    options
+  );
+}
+
+// packages/sdk/src/createClient.ts
+function createClient2(config) {
+  const client = new HttpClient(config);
+  const tokenManager = new TokenManager();
+  if (config.token) {
+    tokenManager.set(config.token);
+  }
+  return {
+    client,
+    tokenManager,
+    setToken(token) {
+      tokenManager.set(token);
+      client.setToken(token);
+    },
+    clearToken() {
+      tokenManager.clear();
+      client.removeToken();
+    }
+  };
+}
+
+// packages/sdk/src/generateHooks.ts
+function generateHooks(api) {
+  let useQuery;
+  let useMutation;
+  let useQueryClient;
+  try {
+    const rq = require("@tanstack/react-query");
+    useQuery = rq.useQuery;
+    useMutation = rq.useMutation;
+    useQueryClient = rq.useQueryClient;
+  } catch {
+    throw new Error(
+      "@tanstack/react-query is required to use generateHooks. Install it with: npm install @tanstack/react-query"
+    );
+  }
+  const hooks = {};
+  for (const [group, actions] of Object.entries(api)) {
+    for (const [action, endpoint2] of Object.entries(actions)) {
+      const method = endpoint2.$def.method;
+      const hookName = toHookName(group, action);
+      if (method === "GET" || method === "DELETE") {
+        hooks[hookName] = (options, queryOptions) => useQuery({
+          queryKey: options ? [...endpoint2.$key, options] : endpoint2.$key,
+          queryFn: () => endpoint2(options),
+          ...queryOptions
+        });
+      } else {
+        hooks[hookName] = (mutationOptions) => {
+          const qc = useQueryClient();
+          return useMutation({
+            ...mutationOptions,
+            mutationFn: (options) => endpoint2(options),
+            onSuccess: (...args) => {
+              qc.invalidateQueries({ queryKey: [group] });
+              mutationOptions?.invalidate?.forEach((ep) => {
+                qc.invalidateQueries({ queryKey: ep.$key });
+              });
+              mutationOptions?.onSuccess?.(...args);
+            }
+          });
+        };
+      }
+    }
+  }
+  return hooks;
+}
+function toHookName(group, action) {
+  const g = group.charAt(0).toUpperCase() + group.slice(1);
+  const a = action.charAt(0).toUpperCase() + action.slice(1);
+  return `use${g}${a}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GenericService,
+  camelToSnakeKey,
+  createClient,
+  createHttpClient,
+  createService,
+  defineApi,
+  endpoint,
+  generateHooks,
+  mapKeysDeep,
+  parseWithSchema,
+  resource,
+  snakeToCamelKey,
+  toCamelCase,
+  toSnakeCase
+});