routesync 1.0.0

package/dist/core.d.ts

@@ -0,0 +1,206 @@
+import { AxiosRequestConfig, AxiosInstance, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+
+interface ServiceConfig {
+    baseURL: string;
+    token?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retry?: RetryConfig;
+    cache?: boolean;
+}
+interface RetryConfig {
+    attempts: number;
+    delay?: number;
+    statusCodes?: number[];
+}
+interface AuthConfig {
+    type: 'bearer' | 'basic' | 'api-key';
+    token?: string;
+    apiKey?: string;
+    apiKeyHeader?: string;
+}
+
+declare class HttpClient {
+    private client;
+    constructor(config: ServiceConfig);
+    private setupInterceptors;
+    setToken(token: string): void;
+    removeToken(): void;
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T>(url: string, body?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    upload<T>(url: string, formData: FormData): Promise<T>;
+    getInstance(): AxiosInstance;
+}
+
+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 RequestOptions {
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+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>;
+}
+interface ApiDefinition {
+    [group: string]: {
+        [action: string]: RouteDefinition;
+    };
+}
+
+declare class Request {
+    private _url;
+    private _method;
+    private _body?;
+    private _options?;
+    url(url: string): this;
+    method(method: HttpMethod): this;
+    body(data: any): this;
+    options(opts: RequestOptions): this;
+    build(): {
+        url: string;
+        method: HttpMethod;
+        body: any;
+        options: RequestOptions | undefined;
+    };
+}
+
+interface ApiResponse<T = any> {
+    success: boolean;
+    message?: string;
+    data: T;
+    meta?: PaginationMeta;
+}
+interface PaginationMeta {
+    current_page: number;
+    last_page: number;
+    per_page: number;
+    total: number;
+    from?: number;
+    to?: number;
+}
+
+declare class Response<T = any> {
+    private raw;
+    constructor(raw: ApiResponse<T>);
+    get data(): T;
+    get success(): boolean;
+    get message(): string | undefined;
+    isOk(): boolean;
+    unwrap(): T;
+}
+
+type RequestInterceptor = (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+type ResponseInterceptor = (response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+type ErrorInterceptor = (error: any) => any;
+declare class Interceptor {
+    private client;
+    constructor(client: AxiosInstance);
+    addRequestInterceptor(onFulfilled: RequestInterceptor, onRejected?: ErrorInterceptor): number;
+    addResponseInterceptor(onFulfilled: ResponseInterceptor, onRejected?: ErrorInterceptor): number;
+    removeRequestInterceptor(id: number): void;
+    removeResponseInterceptor(id: number): void;
+}
+
+declare class TokenManager {
+    private static TOKEN_KEY;
+    private token;
+    set(token: string): void;
+    get(): string | null;
+    clear(): void;
+    exists(): boolean;
+}
+
+declare class AuthMiddleware {
+    private tokenManager;
+    constructor(tokenManager: TokenManager);
+    inject(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig;
+    getAuthHeader(): Record<string, string>;
+}
+
+declare class PathResolver {
+    /**
+     * Resolve path params.
+     * e.g. resolvePath('/produk/:id', { id: 10 }) => '/produk/10'
+     */
+    static resolve(path: string, params?: Record<string, any>): string;
+    static extractParams(path: string): string[];
+    static hasParams(path: string): boolean;
+}
+
+declare class QueryBuilder {
+    static build(params?: Record<string, any>): string;
+    static append(url: string, params?: Record<string, any>): string;
+}
+
+declare class ApiError extends Error {
+    readonly status?: number;
+    readonly errors?: Record<string, string[]>;
+    readonly success = false;
+    constructor(message: string, status?: number, errors?: Record<string, string[]>);
+    isUnauthorized(): boolean;
+    isForbidden(): boolean;
+    isNotFound(): boolean;
+    isValidationError(): boolean;
+    isServerError(): boolean;
+    getFirstError(field: string): string | undefined;
+    getAllErrors(): string[];
+}
+
+declare class ErrorHandler {
+    static handle(error: any): never;
+    static isApiError(error: unknown): error is ApiError;
+}
+
+interface RouteManifest {
+    version: string;
+    baseURL: string;
+    routes: ParsedRoute[];
+    generatedAt: string;
+}
+interface ParsedRoute {
+    name: string;
+    method: string;
+    path: string;
+    auth: boolean;
+    middleware: string[];
+    group?: string;
+    action?: string;
+}
+
+export { type ApiDefinition, ApiError, type ApiResponse, type AuthConfig, AuthMiddleware, ErrorHandler, HttpClient, type HttpMethod, Interceptor, type PaginationMeta, type ParsedRoute, PathResolver, QueryBuilder, Request, type RequestOptions, Response, type RetryConfig, type RouteDefinition, type RouteManifest, type RouteMapper, type RouteParserSchema, type RouteSchema, type RouteSchemaMap, type RouteSchemaValue, type RouteTransform, type RouteTransformMap, type ServiceConfig, TokenManager };

package/dist/core.js

@@ -0,0 +1,353 @@
+"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/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiError: () => ApiError,
+  AuthMiddleware: () => AuthMiddleware,
+  ErrorHandler: () => ErrorHandler,
+  HttpClient: () => HttpClient,
+  Interceptor: () => Interceptor,
+  PathResolver: () => PathResolver,
+  QueryBuilder: () => QueryBuilder,
+  Request: () => Request,
+  Response: () => Response,
+  TokenManager: () => TokenManager
+});
+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/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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthMiddleware,
+  ErrorHandler,
+  HttpClient,
+  Interceptor,
+  PathResolver,
+  QueryBuilder,
+  Request,
+  Response,
+  TokenManager
+});