api-core-lib 12.0.26 → 12.0.27

package/dist/chunk-UWAVU6EF.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+import {
+  __publicField
+} from "./chunk-NRV3EMIJ.js";
+
+// src/core/utils.ts
+import axios from "axios";
+function isAxiosResponse(obj) {
+  return obj && obj.data !== void 0 && obj.status !== void 0 && obj.config !== void 0;
+}
+function buildPaginateQuery(options) {
+  const params = new URLSearchParams();
+  for (const key in options) {
+    const value = options[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (key === "filter" && typeof value === "object" && !Array.isArray(value)) {
+      for (const filterKey in value) {
+        const filterValue = value[filterKey];
+        if (filterValue !== null && filterValue !== void 0) {
+          params.append(`filter[${filterKey}]`, String(filterValue));
+        }
+      }
+    } else if (key === "sortBy" && Array.isArray(value)) {
+      value.forEach((sortItem) => {
+        if (sortItem && sortItem.key && sortItem.direction) {
+          params.append("sortBy[]", `${sortItem.key}:${sortItem.direction}`);
+        }
+      });
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  return params.toString();
+}
+function isServerError(error) {
+  return axios.isAxiosError(error) && error.response !== void 0;
+}
+function isNetworkError(error) {
+  return axios.isAxiosError(error) && error.response === void 0 && error.request !== void 0;
+}
+
+// src/core/processor.ts
+import axios2 from "axios";
+var processResponse = (responseOrError) => {
+  if (isAxiosResponse(responseOrError)) {
+    const response = responseOrError;
+    const rawData = response.data;
+    const isStandardApiResponse = rawData && typeof rawData.success === "boolean" && rawData.data !== void 0;
+    return {
+      data: isStandardApiResponse ? rawData.data : rawData,
+      links: isStandardApiResponse ? rawData.links : void 0,
+      meta: isStandardApiResponse ? rawData.meta : void 0,
+      rawResponse: rawData,
+      loading: false,
+      success: true,
+      error: null,
+      message: isStandardApiResponse ? rawData.message : "Request successful.",
+      validationErrors: []
+    };
+  }
+  if (isServerError(responseOrError)) {
+    const error = responseOrError;
+    const responseData = error.response.data;
+    const status = error.response.status;
+    let defaultMessage = "An unexpected server error occurred.";
+    switch (status) {
+      case 400:
+        defaultMessage = "Bad Request";
+        break;
+      case 401:
+        defaultMessage = "Unauthorized";
+        break;
+      case 403:
+        defaultMessage = "Forbidden";
+        break;
+      case 404:
+        defaultMessage = "Not Found";
+        break;
+      case 422:
+        defaultMessage = "Validation Failed";
+        break;
+      case 500:
+        defaultMessage = "Internal Server Error";
+        break;
+      case 503:
+        defaultMessage = "Service Unavailable";
+        break;
+      default:
+        defaultMessage = `Server Error (${status})`;
+    }
+    const finalApiError = {
+      message: responseData?.message || defaultMessage,
+      status,
+      code: responseData?.code || error.code,
+      errors: responseData?.errors || []
+    };
+    return {
+      data: null,
+      rawResponse: responseData,
+      error: finalApiError,
+      validationErrors: finalApiError.errors,
+      success: false,
+      loading: false,
+      message: finalApiError.message
+    };
+  }
+  if (isNetworkError(responseOrError)) {
+    const error = responseOrError;
+    return {
+      data: null,
+      rawResponse: error.request,
+      error: { message: "Network Error: Unable to connect.", status: 0, code: error.code },
+      success: false,
+      loading: false,
+      message: "Network Error."
+    };
+  }
+  if (axios2.isCancel(responseOrError)) {
+    return {
+      data: null,
+      rawResponse: null,
+      error: { message: "Request Canceled.", status: 499 },
+      success: false,
+      loading: false,
+      message: "Request Canceled."
+    };
+  }
+  return {
+    data: null,
+    rawResponse: responseOrError,
+    error: { message: "An unknown error occurred.", status: -1 },
+    success: false,
+    loading: false,
+    message: "An unknown error occurred."
+  };
+};
+
+// src/core/buildDynamicUrl.ts
+function buildDynamicUrl(template, params) {
+  if (!params) {
+    return template;
+  }
+  return template.replace(/\{(\w+)\}/g, (placeholder, key) => {
+    return params.hasOwnProperty(key) ? String(params[key]) : placeholder;
+  });
+}
+
+// src/services/crud.ts
+function createApiServices(axiosInstance, baseEndpoint) {
+  const resolveUrl = (config = {}, id) => {
+    const endpointTemplate = config.endpoint || (id != null ? `${baseEndpoint}/{id}` : baseEndpoint);
+    const params = id != null ? { id, tenant: id, tenantId: id, recordId: id } : {};
+    return buildDynamicUrl(endpointTemplate, params);
+  };
+  const get = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const getWithQuery = async (query, config) => {
+    const url = `${baseEndpoint}?${query}`;
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const post = async (data, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.post(url, data, config);
+      console.log("[lib] response POST: ", response);
+      console.log("[lib] response processResponse POST: ", processResponse(response));
+      return processResponse(response);
+    } catch (error) {
+      console.log("[lib] response error POST: ", processResponse(error));
+      return processResponse(error);
+    }
+  };
+  const put = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.put(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const patch = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.patch(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const remove = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.delete(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const bulkDelete = async (ids, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.delete(url, { data: { ids }, ...config });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const upload = async (file, additionalData, config) => {
+    const url = resolveUrl(config);
+    const formData = new FormData();
+    formData.append("file", file);
+    if (additionalData) {
+      Object.keys(additionalData).forEach((key) => formData.append(key, String(additionalData[key])));
+    }
+    try {
+      const response = await axiosInstance.post(url, formData, {
+        ...config,
+        headers: { ...config?.headers, "Content-Type": "multipart/form-data" }
+      });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  return { get, getWithQuery, post, put, patch, remove, bulkDelete, upload };
+}
+async function callDynamicApi(axiosInstance, baseEndpoint, actionConfig, params) {
+  const { pathParams, body, config } = params;
+  const urlTemplate = `${baseEndpoint}${actionConfig.path}`;
+  const finalUrl = buildDynamicUrl(urlTemplate, pathParams || {});
+  try {
+    const { method } = actionConfig;
+    let response;
+    if (method === "POST" || method === "PUT" || method === "PATCH") {
+      response = await axiosInstance[method.toLowerCase()](finalUrl, body, config);
+    } else if (method === "DELETE") {
+      response = await axiosInstance.delete(finalUrl, { data: body, ...config });
+    } else {
+      response = await axiosInstance.get(finalUrl, { params: body, ...config });
+    }
+    return processResponse(response);
+  } catch (error) {
+    return processResponse(error);
+  }
+}
+
+// src/core/globalStateManager.ts
+var createInitialState = () => ({
+  data: null,
+  links: void 0,
+  meta: void 0,
+  error: null,
+  loading: false,
+  success: false,
+  called: false,
+  isStale: false,
+  message: void 0,
+  validationErrors: [],
+  rawResponse: null
+});
+var GlobalStateManager = class {
+  constructor() {
+    __publicField(this, "store", /* @__PURE__ */ new Map());
+  }
+  getSnapshot(key) {
+    if (!this.store.has(key)) {
+      const initialState = createInitialState();
+      this.store.set(key, { state: initialState, listeners: /* @__PURE__ */ new Set() });
+    }
+    return this.store.get(key).state;
+  }
+  /**
+   * يسجل دالة callback للاستماع إلى التغييرات على مفتاح معين.
+   * @returns دالة لإلغاء الاشتراك.
+   */
+  subscribe(key, callback) {
+    if (!this.store.has(key)) {
+      this.store.set(key, { state: createInitialState(), listeners: /* @__PURE__ */ new Set() });
+    }
+    const item = this.store.get(key);
+    item.listeners.add(callback);
+    return () => {
+      item.listeners.delete(callback);
+    };
+  }
+  /**
+   * يحدّث الحالة لمفتاح معين ويقوم بإعلام جميع المشتركين.
+   */
+  setState(key, updater) {
+    const currentState = this.getSnapshot(key);
+    const newState = updater(currentState);
+    if (Object.is(currentState, newState)) {
+      return;
+    }
+    const item = this.store.get(key);
+    item.state = newState;
+    item.listeners.forEach((listener) => listener());
+  }
+  /**
+   * يجعل البيانات المرتبطة بمفتاح معين "قديمة" (stale).
+   */
+  invalidate(key) {
+    const state = this.getSnapshot(key);
+    if (state.called) {
+      this.setState(key, (prev) => ({ ...prev, isStale: true }));
+    }
+  }
+  /**
+  * [نسخة محدثة وأكثر قوة]
+  * يجعل كل البيانات التي تبدأ بمفتاح معين "قديمة" (stale).
+  * @example invalidateByPrefix('myModule/list::') سيبطل كل صفحات القائمة.
+  */
+  invalidateByPrefix(prefix) {
+    this.store.forEach((value, key) => {
+      if (key.startsWith(prefix)) {
+        const state = this.getSnapshot(key);
+        if (state.called) {
+          this.setState(key, (prev) => ({ ...prev, isStale: true }));
+        }
+      }
+    });
+  }
+  /**
+  * Serializes the current state of the query store into a JSON string.
+  * This is used on the server to pass the initial state to the client.
+  * @returns A JSON string representing the dehydrated state.
+  */
+  dehydrate() {
+    const stateToPersist = {};
+    this.store.forEach((value, key) => {
+      if (value.state.called) {
+        stateToPersist[key] = value.state;
+      }
+    });
+    return JSON.stringify(stateToPersist);
+  }
+  /**
+   * Merges a dehydrated state object into the current store.
+   * This is used on the client to hydrate the state received from the server.
+   * @param hydratedState - A JSON string from the `dehydrate` method.
+   */
+  rehydrate(hydratedState) {
+    try {
+      const parsedState = JSON.parse(hydratedState);
+      for (const key in parsedState) {
+        this.setState(key, () => parsedState[key]);
+      }
+    } catch (e) {
+      console.error("[api-core-lib] Failed to rehydrate state:", e);
+    }
+  }
+};
+var globalStateManager = new GlobalStateManager();
+
+// src/core/cacheKey.ts
+var generateCacheKey = (moduleName, actionName, input, callOptions = {}) => {
+  const params = { path: callOptions.pathParams, body: input };
+  try {
+    return `${moduleName}/${actionName}::${JSON.stringify(params)}`;
+  } catch (error) {
+    console.warn("Could not stringify cache key params, falling back to timestamp.", { moduleName, actionName, error });
+    return `${moduleName}/${actionName}::${Date.now()}`;
+  }
+};
+
+export {
+  buildPaginateQuery,
+  processResponse,
+  createApiServices,
+  callDynamicApi,
+  globalStateManager,
+  generateCacheKey
+};

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import "./chunk-NRV3EMIJ.js";
+
+// src/cli.ts
+import { program } from "commander";
+import path2 from "path";
+
+// src/generator/index.ts
+import fs from "fs";
+import path from "path";
+import axios from "axios";
+import chalk from "chalk";
+import dotenv from "dotenv";
+import openapiTS from "openapi-typescript";
+
+// src/generator/module-parser.ts
+function parseSpecToModules(spec) {
+  const modules = {};
+  for (const apiPath in spec.paths) {
+    for (const method in spec.paths[apiPath]) {
+      const endpoint = spec.paths[apiPath][method];
+      if (!endpoint.tags || endpoint.tags.length === 0) continue;
+      const tagName = endpoint.tags[0];
+      const moduleName = tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "") + "Api";
+      if (!modules[moduleName]) {
+        modules[moduleName] = {
+          baseEndpoint: "",
+          // سيتم ملء المسار الكامل في path
+          actions: {}
+        };
+      }
+      const actionName = endpoint.operationId || method + apiPath.replace(/[\/{}]+/g, "_");
+      modules[moduleName].actions[actionName] = {
+        method: method.toUpperCase(),
+        path: apiPath,
+        description: endpoint.summary || "No description available.",
+        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
+        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
+        // افتراض ذكي
+        invalidates: []
+        // يمكن تركه فارغًا
+      };
+    }
+  }
+  return modules;
+}
+
+// src/generator/index.ts
+async function runGenerator(options) {
+  console.log(chalk.cyan(`Starting API module generation...`));
+  console.log(chalk.gray(`Output directory: ${options.output}`));
+  console.log(chalk.gray(`.env path: ${options.envPath}`));
+  dotenv.config({ path: options.envPath });
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL || process.env.API_URL;
+  if (!apiUrl) {
+    console.error(chalk.red("Error: API_URL or NEXT_PUBLIC_API_URL not found in .env file."));
+    process.exit(1);
+  }
+  try {
+    const specUrl = `${apiUrl}/api-docs/json`;
+    console.log(`Fetching OpenAPI spec from ${specUrl}...`);
+    const response = await axios.get(specUrl);
+    const spec = response.data;
+    if (!fs.existsSync(options.output)) {
+      fs.mkdirSync(options.output, { recursive: true });
+    }
+    console.log("Generating TypeScript types...");
+    const typesContent = await openapiTS(spec);
+    const typesPath = path.join(options.output, "api-types.generated.ts");
+    fs.writeFileSync(typesPath, typesContent);
+    console.log(chalk.green(`\u2713 Types generated successfully at ${typesPath}`));
+    console.log("Generating API modules...");
+    const modules = parseSpecToModules(spec);
+    for (const moduleName in modules) {
+      const moduleConfig = modules[moduleName];
+      const fileName = `${moduleName}.module.ts`;
+      const filePath = path.join(options.output, fileName);
+      const fileContent = `
+// This file is auto-generated by api-core-lib.
+// Do not edit this file directly.
+
+import type { ApiModuleConfig } from 'api-core-lib';
+import type { paths } from './api-types.generated'; // \u0631\u0628\u0637 \u0627\u0644\u0623\u0646\u0648\u0627\u0639 \u0627\u0644\u0645\u0648\u0644\u062F\u0629
+
+// A more advanced generator could automatically map the correct input/output types.
+// For now, we use 'any' as a placeholder.
+export const ${moduleName}Module: ApiModuleConfig<any> = ${JSON.stringify(moduleConfig, null, 2)};
+`;
+      fs.writeFileSync(filePath, fileContent);
+      console.log(chalk.green(`\u2713 Module generated: ${fileName}`));
+    }
+    console.log(chalk.bold.green("\n\u{1F389} API generation complete!"));
+  } catch (error) {
+    console.error(chalk.red("\nAn error occurred during generation:"));
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+console.log("API Core Lib - Code Generator");
+program.option("-o, --output <path>", "Output directory for generated files", "src/lib/api-generated").option("--env-path <path>", ".env file path", path2.resolve(process.cwd(), ".env")).action((options) => {
+  const absoluteOutputPath = path2.resolve(process.cwd(), options.output);
+  runGenerator({ ...options, output: absoluteOutputPath });
+});
+program.parse(process.argv);