routesync 1.0.0

package/dist/core.mjs

@@ -0,0 +1,307 @@
+// packages/core/src/client/HttpClient.ts
+import axios from "axios";
+var HttpClient = class {
+  constructor(config) {
+    this.client = axios.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/client/Request.ts
+var Request = class {
+  constructor() {
+    this._url = "";
+    this._method = "GET";
+  }
+  url(url) {
+    this._url = url;
+    return this;
+  }
+  method(method) {
+    this._method = method;
+    return this;
+  }
+  body(data) {
+    this._body = data;
+    return this;
+  }
+  options(opts) {
+    this._options = opts;
+    return this;
+  }
+  build() {
+    return {
+      url: this._url,
+      method: this._method,
+      body: this._body,
+      options: this._options
+    };
+  }
+};
+
+// packages/core/src/client/Response.ts
+var Response = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get data() {
+    return this.raw.data;
+  }
+  get success() {
+    return this.raw.success;
+  }
+  get message() {
+    return this.raw.message;
+  }
+  isOk() {
+    return this.raw.success === true;
+  }
+  unwrap() {
+    if (!this.isOk()) {
+      throw new Error(this.raw.message ?? "Response failed");
+    }
+    return this.raw.data;
+  }
+};
+
+// packages/core/src/client/Interceptor.ts
+var Interceptor = class {
+  constructor(client) {
+    this.client = client;
+  }
+  addRequestInterceptor(onFulfilled, onRejected) {
+    return this.client.interceptors.request.use(onFulfilled, onRejected);
+  }
+  addResponseInterceptor(onFulfilled, onRejected) {
+    return this.client.interceptors.response.use(onFulfilled, onRejected);
+  }
+  removeRequestInterceptor(id) {
+    this.client.interceptors.request.eject(id);
+  }
+  removeResponseInterceptor(id) {
+    this.client.interceptors.response.eject(id);
+  }
+};
+
+// 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/auth/AuthMiddleware.ts
+var AuthMiddleware = class {
+  constructor(tokenManager) {
+    this.tokenManager = tokenManager;
+  }
+  inject(config) {
+    const token = this.tokenManager.get();
+    if (token) {
+      config.headers = config.headers ?? {};
+      config.headers["Authorization"] = `Bearer ${token}`;
+    }
+    return config;
+  }
+  getAuthHeader() {
+    const token = this.tokenManager.get();
+    if (!token) return {};
+    return { Authorization: `Bearer ${token}` };
+  }
+};
+
+// 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/core/src/routing/QueryBuilder.ts
+var QueryBuilder = class {
+  static build(params) {
+    if (!params || Object.keys(params).length === 0) return "";
+    const query = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => {
+      if (Array.isArray(v)) {
+        return v.map((item) => `${encodeURIComponent(k)}[]=${encodeURIComponent(item)}`).join("&");
+      }
+      return `${encodeURIComponent(k)}=${encodeURIComponent(v)}`;
+    }).join("&");
+    return query ? `?${query}` : "";
+  }
+  static append(url, params) {
+    const query = this.build(params);
+    return url + query;
+  }
+};
+
+// packages/core/src/errors/ApiError.ts
+var ApiError = class extends Error {
+  constructor(message, status, errors) {
+    super(message);
+    this.success = false;
+    this.name = "ApiError";
+    this.status = status;
+    this.errors = errors;
+  }
+  isUnauthorized() {
+    return this.status === 401;
+  }
+  isForbidden() {
+    return this.status === 403;
+  }
+  isNotFound() {
+    return this.status === 404;
+  }
+  isValidationError() {
+    return this.status === 422;
+  }
+  isServerError() {
+    return (this.status ?? 0) >= 500;
+  }
+  getFirstError(field) {
+    return this.errors?.[field]?.[0];
+  }
+  getAllErrors() {
+    if (!this.errors) return [];
+    return Object.values(this.errors).flat();
+  }
+};
+
+// packages/core/src/errors/ErrorHandler.ts
+var ErrorHandler = class {
+  static handle(error) {
+    if (error instanceof ApiError) throw error;
+    if (error?.response) {
+      throw new ApiError(
+        error.response.data?.message ?? "Request failed",
+        error.response.status,
+        error.response.data?.errors
+      );
+    }
+    if (error?.request) {
+      throw new ApiError("No response received from server");
+    }
+    throw new ApiError(error?.message ?? "Unknown error occurred");
+  }
+  static isApiError(error) {
+    return error instanceof ApiError;
+  }
+};
+export {
+  ApiError,
+  AuthMiddleware,
+  ErrorHandler,
+  HttpClient,
+  Interceptor,
+  PathResolver,
+  QueryBuilder,
+  Request,
+  Response,
+  TokenManager
+};

package/dist/react.d.mts

@@ -0,0 +1,95 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RouteTransform = (value: unknown) => unknown;
+interface RouteTransformMap {
+    params?: RouteTransform;
+    query?: RouteTransform;
+    body?: RouteTransform;
+    request?: RouteTransform;
+    response?: RouteTransform;
+}
+type RouteMapper = RouteTransform | RouteTransformMap;
+interface RouteParserSchema {
+    parse?: RouteTransform;
+    safeParse?: RouteTransform;
+}
+interface RouteSchemaMap {
+    params?: RouteSchemaValue;
+    query?: RouteSchemaValue;
+    body?: RouteSchemaValue;
+    request?: RouteSchemaValue;
+    response?: RouteSchemaValue;
+}
+type RouteSchemaValue = RouteTransform | RouteParserSchema;
+type RouteSchema = RouteSchemaValue | RouteSchemaMap;
+interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    auth?: boolean;
+    schema?: RouteSchema;
+    mapper?: RouteMapper;
+    headers?: Record<string, string>;
+    cache?: unknown;
+    retry?: unknown;
+    body?: Record<string, any>;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+}
+
+type CallOptions = {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    body?: Record<string, any>;
+};
+interface EndpointCallable {
+    (options?: CallOptions): Promise<any>;
+    /** Original RouteDefinition — used by useApiQuery / useApiMutation */
+    $def: RouteDefinition;
+    /** Stable TanStack query key: [group, action] */
+    $key: string[];
+}
+
+/**
+ * useApiQuery — accepts an endpoint callable directly.
+ *
+ * Usage:
+ *   const { data, isLoading } = useApiQuery(api.produk.list)
+ *   const { data } = useApiQuery(api.produk.detail, { params: { id: 10 } })
+ */
+declare function useApiQuery<T = any>(endpoint: EndpointCallable, options?: CallOptions, queryOptions?: Omit<UseQueryOptions<T>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<NoInfer<T>, Error>;
+
+/**
+ * useApiMutation — accepts an endpoint callable directly.
+ * Auto-invalidates the endpoint's group on success.
+ *
+ * Usage:
+ *   const mutation = useApiMutation(api.cart.addItem)
+ *   mutation.mutate({ body: { produk_id: 1, qty: 2 } })
+ *
+ *   // Custom invalidation:
+ *   const mutation = useApiMutation(api.orders.checkout, {
+ *     invalidate: [api.cart.list, api.orders.index],
+ *   })
+ */
+interface ApiMutationOptions<TData, TVariables> extends Omit<UseMutationOptions<TData, unknown, TVariables>, 'mutationFn'> {
+    /** Extra endpoints to invalidate on success (in addition to the auto group invalidation). */
+    invalidate?: EndpointCallable[];
+}
+declare function useApiMutation<TData = any, TVariables extends CallOptions = CallOptions>(endpoint: EndpointCallable, options?: ApiMutationOptions<TData, TVariables>): _tanstack_react_query.UseMutationResult<TData, unknown, TVariables, unknown>;
+
+/**
+ * createHooks — generate typed hooks from an api group.
+ *
+ * Usage:
+ *   const cartHooks = createHooks(api.cart)
+ *   const { useList, useAddItem } = cartHooks
+ *
+ *   // In component:
+ *   const { data } = useList()
+ *   const mutation = useAddItem()
+ */
+declare function createHooks<T extends Record<string, EndpointCallable>>(group: T): { [K in keyof T as `use${Capitalize<string & K>}`]: T[K] extends EndpointCallable ? T[K]["$def"]["method"] extends "GET" | "DELETE" ? (options?: any, queryOptions?: any) => ReturnType<typeof useApiQuery> : (options?: any) => ReturnType<typeof useApiMutation> : never; };
+
+export { type ApiMutationOptions, createHooks, useApiMutation, useApiQuery };

package/dist/react.d.ts

@@ -0,0 +1,95 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type RouteTransform = (value: unknown) => unknown;
+interface RouteTransformMap {
+    params?: RouteTransform;
+    query?: RouteTransform;
+    body?: RouteTransform;
+    request?: RouteTransform;
+    response?: RouteTransform;
+}
+type RouteMapper = RouteTransform | RouteTransformMap;
+interface RouteParserSchema {
+    parse?: RouteTransform;
+    safeParse?: RouteTransform;
+}
+interface RouteSchemaMap {
+    params?: RouteSchemaValue;
+    query?: RouteSchemaValue;
+    body?: RouteSchemaValue;
+    request?: RouteSchemaValue;
+    response?: RouteSchemaValue;
+}
+type RouteSchemaValue = RouteTransform | RouteParserSchema;
+type RouteSchema = RouteSchemaValue | RouteSchemaMap;
+interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    auth?: boolean;
+    schema?: RouteSchema;
+    mapper?: RouteMapper;
+    headers?: Record<string, string>;
+    cache?: unknown;
+    retry?: unknown;
+    body?: Record<string, any>;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+}
+
+type CallOptions = {
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    body?: Record<string, any>;
+};
+interface EndpointCallable {
+    (options?: CallOptions): Promise<any>;
+    /** Original RouteDefinition — used by useApiQuery / useApiMutation */
+    $def: RouteDefinition;
+    /** Stable TanStack query key: [group, action] */
+    $key: string[];
+}
+
+/**
+ * useApiQuery — accepts an endpoint callable directly.
+ *
+ * Usage:
+ *   const { data, isLoading } = useApiQuery(api.produk.list)
+ *   const { data } = useApiQuery(api.produk.detail, { params: { id: 10 } })
+ */
+declare function useApiQuery<T = any>(endpoint: EndpointCallable, options?: CallOptions, queryOptions?: Omit<UseQueryOptions<T>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<NoInfer<T>, Error>;
+
+/**
+ * useApiMutation — accepts an endpoint callable directly.
+ * Auto-invalidates the endpoint's group on success.
+ *
+ * Usage:
+ *   const mutation = useApiMutation(api.cart.addItem)
+ *   mutation.mutate({ body: { produk_id: 1, qty: 2 } })
+ *
+ *   // Custom invalidation:
+ *   const mutation = useApiMutation(api.orders.checkout, {
+ *     invalidate: [api.cart.list, api.orders.index],
+ *   })
+ */
+interface ApiMutationOptions<TData, TVariables> extends Omit<UseMutationOptions<TData, unknown, TVariables>, 'mutationFn'> {
+    /** Extra endpoints to invalidate on success (in addition to the auto group invalidation). */
+    invalidate?: EndpointCallable[];
+}
+declare function useApiMutation<TData = any, TVariables extends CallOptions = CallOptions>(endpoint: EndpointCallable, options?: ApiMutationOptions<TData, TVariables>): _tanstack_react_query.UseMutationResult<TData, unknown, TVariables, unknown>;
+
+/**
+ * createHooks — generate typed hooks from an api group.
+ *
+ * Usage:
+ *   const cartHooks = createHooks(api.cart)
+ *   const { useList, useAddItem } = cartHooks
+ *
+ *   // In component:
+ *   const { data } = useList()
+ *   const mutation = useAddItem()
+ */
+declare function createHooks<T extends Record<string, EndpointCallable>>(group: T): { [K in keyof T as `use${Capitalize<string & K>}`]: T[K] extends EndpointCallable ? T[K]["$def"]["method"] extends "GET" | "DELETE" ? (options?: any, queryOptions?: any) => ReturnType<typeof useApiQuery> : (options?: any) => ReturnType<typeof useApiMutation> : never; };
+
+export { type ApiMutationOptions, createHooks, useApiMutation, useApiQuery };

package/dist/react.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/react/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createHooks: () => createHooks,
+  useApiMutation: () => useApiMutation,
+  useApiQuery: () => useApiQuery
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/react/src/hooks/useQuery.ts
+var import_react_query = require("@tanstack/react-query");
+function useApiQuery(endpoint, options, queryOptions) {
+  const queryKey = options ? [...endpoint.$key, options] : endpoint.$key;
+  return (0, import_react_query.useQuery)({
+    queryKey,
+    queryFn: () => endpoint(options),
+    ...queryOptions
+  });
+}
+
+// packages/react/src/hooks/useMutation.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useApiMutation(endpoint, options) {
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  const [group] = endpoint.$key;
+  return (0, import_react_query2.useMutation)({
+    ...options,
+    mutationFn: (variables) => endpoint(variables),
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: [group] });
+      options?.invalidate?.forEach((ep) => {
+        queryClient.invalidateQueries({ queryKey: ep.$key });
+      });
+      options?.onSuccess?.(...args);
+    }
+  });
+}
+
+// packages/react/src/hooks/createHooks.ts
+function createHooks(group) {
+  const hooks = {};
+  for (const [action, endpoint] of Object.entries(group)) {
+    const method = endpoint.$def.method;
+    const hookName = `use${action.charAt(0).toUpperCase()}${action.slice(1)}`;
+    if (method === "GET" || method === "DELETE") {
+      hooks[hookName] = (options, queryOptions) => useApiQuery(endpoint, options, queryOptions);
+    } else {
+      hooks[hookName] = (mutationOptions) => useApiMutation(endpoint, mutationOptions);
+    }
+  }
+  return hooks;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHooks,
+  useApiMutation,
+  useApiQuery
+});

package/dist/react.mjs

@@ -0,0 +1,48 @@
+// packages/react/src/hooks/useQuery.ts
+import { useQuery } from "@tanstack/react-query";
+function useApiQuery(endpoint, options, queryOptions) {
+  const queryKey = options ? [...endpoint.$key, options] : endpoint.$key;
+  return useQuery({
+    queryKey,
+    queryFn: () => endpoint(options),
+    ...queryOptions
+  });
+}
+
+// packages/react/src/hooks/useMutation.ts
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+function useApiMutation(endpoint, options) {
+  const queryClient = useQueryClient();
+  const [group] = endpoint.$key;
+  return useMutation({
+    ...options,
+    mutationFn: (variables) => endpoint(variables),
+    onSuccess: (...args) => {
+      queryClient.invalidateQueries({ queryKey: [group] });
+      options?.invalidate?.forEach((ep) => {
+        queryClient.invalidateQueries({ queryKey: ep.$key });
+      });
+      options?.onSuccess?.(...args);
+    }
+  });
+}
+
+// packages/react/src/hooks/createHooks.ts
+function createHooks(group) {
+  const hooks = {};
+  for (const [action, endpoint] of Object.entries(group)) {
+    const method = endpoint.$def.method;
+    const hookName = `use${action.charAt(0).toUpperCase()}${action.slice(1)}`;
+    if (method === "GET" || method === "DELETE") {
+      hooks[hookName] = (options, queryOptions) => useApiQuery(endpoint, options, queryOptions);
+    } else {
+      hooks[hookName] = (mutationOptions) => useApiMutation(endpoint, mutationOptions);
+    }
+  }
+  return hooks;
+}
+export {
+  createHooks,
+  useApiMutation,
+  useApiQuery
+};