@visulima/crud 2.0.46 → 3.0.0-alpha.10

package/dist/packem_shared/base-crud-handler-DgrOMhoH.mjs

@@ -0,0 +1,587 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+import createHttpError from 'http-errors';
+import { ApiError } from 'next/dist/server/api-utils/index.js';
+import { paginate } from '@visulima/pagination';
+const {
+  URL
+} = __cjs_getBuiltinModule("node:url");
+import { RouteType } from './RouteType-CB2xrWdf.mjs';
+import { g as getAccessibleRoutes } from './get-accessible-routes-sV5SDdFn.mjs';
+import { match } from 'path-to-regexp';
+
+const createHandler = async ({ adapter, query, request, resourceName }) => {
+  const resources = await adapter.create(resourceName, request.body, query);
+  return {
+    data: resources,
+    status: 201
+  };
+};
+
+const deleteHandler = async ({ adapter, query, resourceId, resourceName }) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (typeof resource === "object") {
+    const deletedResource = await adapter.delete(resourceName, resourceId, query);
+    return {
+      data: deletedResource,
+      status: 200
+    };
+  }
+  throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+};
+
+const listHandler = async ({ adapter, pagination, query, resourceName }) => {
+  let isPaginated = false;
+  let paginationOptions;
+  if (query.page !== void 0) {
+    if (query.page <= 0) {
+      throw new Error("page query must be a strictly positive number");
+    }
+    paginationOptions = {
+      page: query.page,
+      perPage: query.limit ?? pagination.perPage
+    };
+  }
+  if (paginationOptions) {
+    isPaginated = true;
+    query.skip = (paginationOptions.page - 1) * paginationOptions.perPage;
+    query.limit = paginationOptions.perPage;
+  }
+  const resources = await adapter.getAll(resourceName, query);
+  if (isPaginated) {
+    const { page, total } = await adapter.getPaginationData(resourceName, query);
+    const paginator = paginate(page, paginationOptions.perPage, total, resources);
+    return {
+      data: paginator.toJSON(),
+      status: 200
+    };
+  }
+  return {
+    data: resources,
+    status: 200
+  };
+};
+
+const readHandler = async ({ adapter, query, resourceId, resourceName }) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (typeof resource !== "object") {
+    throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+  }
+  return {
+    data: resource,
+    status: 200
+  };
+};
+
+const updateHandler = async ({ adapter, query, request, resourceId, resourceName }) => {
+  const resource = await adapter.getOne(resourceName, resourceId, query);
+  if (typeof resource === "object") {
+    const updatedResource = await adapter.update(resourceName, resourceId, request.body, query);
+    return {
+      data: updatedResource,
+      status: 201
+    };
+  }
+  throw createHttpError(404, `${resourceName} ${resourceId} not found`);
+};
+
+const isObject = (value) => {
+  const type = typeof value;
+  return value !== null && (type === "object" || type === "function");
+};
+const disallowedKeys = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+const MAX_ARRAY_INDEX = 1e6;
+const isDigit = (character) => character >= "0" && character <= "9";
+function shouldCoerceToNumber(segment) {
+  if (segment === "0") {
+    return true;
+  }
+  if (/^[1-9]\d*$/.test(segment)) {
+    const parsedNumber = Number.parseInt(segment, 10);
+    return parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX;
+  }
+  return false;
+}
+function processSegment(segment, parts) {
+  if (disallowedKeys.has(segment)) {
+    return false;
+  }
+  if (segment && shouldCoerceToNumber(segment)) {
+    parts.push(Number.parseInt(segment, 10));
+  } else {
+    parts.push(segment);
+  }
+  return true;
+}
+function parsePath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof path}`);
+  }
+  const parts = [];
+  let currentSegment = "";
+  let currentPart = "start";
+  let isEscaping = false;
+  let position = 0;
+  for (const character of path) {
+    position++;
+    if (isEscaping) {
+      currentSegment += character;
+      isEscaping = false;
+      continue;
+    }
+    if (character === "\\") {
+      if (currentPart === "index") {
+        throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+      }
+      if (currentPart === "indexEnd") {
+        throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+      }
+      isEscaping = true;
+      currentPart = currentPart === "start" ? "property" : currentPart;
+      continue;
+    }
+    switch (character) {
+      case ".": {
+        if (currentPart === "index") {
+          throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "property";
+          break;
+        }
+        if (!processSegment(currentSegment, parts)) {
+          return [];
+        }
+        currentSegment = "";
+        currentPart = "property";
+        break;
+      }
+      case "[": {
+        if (currentPart === "index") {
+          throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "index";
+          break;
+        }
+        if (currentPart === "property" || currentPart === "start") {
+          if ((currentSegment || currentPart === "property") && !processSegment(currentSegment, parts)) {
+            return [];
+          }
+          currentSegment = "";
+        }
+        currentPart = "index";
+        break;
+      }
+      case "]": {
+        if (currentPart === "index") {
+          if (currentSegment === "") {
+            const lastSegment = parts.pop() || "";
+            currentSegment = lastSegment + "[]";
+            currentPart = "property";
+          } else {
+            const parsedNumber = Number.parseInt(currentSegment, 10);
+            const isValidInteger = !Number.isNaN(parsedNumber) && Number.isFinite(parsedNumber) && parsedNumber >= 0 && parsedNumber <= Number.MAX_SAFE_INTEGER && parsedNumber <= MAX_ARRAY_INDEX && currentSegment === String(parsedNumber);
+            if (isValidInteger) {
+              parts.push(parsedNumber);
+            } else {
+              parts.push(currentSegment);
+            }
+            currentSegment = "";
+            currentPart = "indexEnd";
+          }
+          break;
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+        }
+        currentSegment += character;
+        break;
+      }
+      default: {
+        if (currentPart === "index" && !isDigit(character)) {
+          throw new Error(`Invalid character '${character}' in an index at position ${position}`);
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error(`Invalid character '${character}' after an index at position ${position}`);
+        }
+        if (currentPart === "start") {
+          currentPart = "property";
+        }
+        currentSegment += character;
+      }
+    }
+  }
+  if (isEscaping) {
+    currentSegment += "\\";
+  }
+  switch (currentPart) {
+    case "property": {
+      if (!processSegment(currentSegment, parts)) {
+        return [];
+      }
+      break;
+    }
+    case "index": {
+      throw new Error("Index was not closed");
+    }
+    case "start": {
+      parts.push("");
+      break;
+    }
+  }
+  return parts;
+}
+function normalizePath(path) {
+  if (typeof path === "string") {
+    return parsePath(path);
+  }
+  if (Array.isArray(path)) {
+    const normalized = [];
+    for (const [index, segment] of path.entries()) {
+      if (typeof segment !== "string" && typeof segment !== "number") {
+        throw new TypeError(`Expected a string or number for path segment at index ${index}, got ${typeof segment}`);
+      }
+      if (typeof segment === "number" && !Number.isFinite(segment)) {
+        throw new TypeError(`Path segment at index ${index} must be a finite number, got ${segment}`);
+      }
+      if (disallowedKeys.has(segment)) {
+        return [];
+      }
+      if (typeof segment === "string" && shouldCoerceToNumber(segment)) {
+        normalized.push(Number.parseInt(segment, 10));
+      } else {
+        normalized.push(segment);
+      }
+    }
+    return normalized;
+  }
+  return [];
+}
+function setProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string" && !Array.isArray(path)) {
+    return object;
+  }
+  const root = object;
+  const pathArray = normalizePath(path);
+  if (pathArray.length === 0) {
+    return object;
+  }
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    if (index === pathArray.length - 1) {
+      object[key] = value;
+    } else if (!isObject(object[key])) {
+      const nextKey = pathArray[index + 1];
+      const shouldCreateArray = typeof nextKey === "number";
+      object[key] = shouldCreateArray ? [] : {};
+    }
+    object = object[key];
+  }
+  return root;
+}
+
+const parseRecursive = (select) => {
+  const selectFields = {};
+  const fields = select.split(",");
+  fields.forEach((field) => {
+    setProperty(selectFields, field, true);
+  });
+  return selectFields;
+};
+const parseWhere = (where) => {
+  const whereObject = JSON.parse(where);
+  const parsed = {};
+  Object.keys(whereObject).forEach((key) => {
+    setProperty(parsed, key, whereObject[key]);
+  });
+  return parsed;
+};
+const parseOrderBy = (orderBy) => {
+  const parsed = {};
+  const orderByObject = JSON.parse(orderBy);
+  if (Object.keys(orderByObject).length > 0) {
+    const key = Object.keys(orderByObject)[0];
+    if (orderByObject[key] === "$asc" || orderByObject[key] === "$desc") {
+      parsed[key] = orderByObject[key];
+    }
+  }
+  if (Object.keys(parsed).length !== 1) {
+    throw new Error("orderBy needs to be an object with exactly 1 property with either $asc or $desc value");
+  }
+  return parsed;
+};
+const parseQuery = (url) => {
+  if (url) {
+    const { searchParams } = new URL(url);
+    const parsedQuery = {};
+    if (searchParams.get("select")) {
+      parsedQuery.select = parseRecursive(searchParams.get("select"));
+    }
+    if (searchParams.get("include")) {
+      parsedQuery.include = parseRecursive(searchParams.get("include"));
+    }
+    if (searchParams.get("where")) {
+      parsedQuery.where = parseWhere(searchParams.get("where"));
+    }
+    if (searchParams.get("orderBy")) {
+      parsedQuery.orderBy = parseOrderBy(searchParams.get("orderBy"));
+    }
+    if (searchParams.has("limit")) {
+      parsedQuery.limit = Number.isFinite(+searchParams.get("limit")) ? +searchParams.get("limit") : void 0;
+    }
+    if (searchParams.has("skip")) {
+      parsedQuery.skip = Number.isFinite(+searchParams.get("skip")) ? +searchParams.get("skip") : void 0;
+    }
+    if (searchParams.get("distinct")) {
+      parsedQuery.distinct = searchParams.get("distinct");
+    }
+    if (searchParams.get("page")) {
+      parsedQuery.page = Number.isFinite(+searchParams.get("page")) ? +searchParams.get("page") : void 0;
+    }
+    return {
+      originalQuery: Object.fromEntries(searchParams.entries()),
+      ...parsedQuery
+    };
+  }
+  return {};
+};
+
+const formatResourceId = (resourceId) => Number.isSafeInteger(+resourceId) ? +resourceId : resourceId;
+
+const ensureCamelCase = (string_) => `${string_.charAt(0).toLowerCase()}${string_.slice(1)}`;
+const getResourceNameFromUrl = (url, models) => {
+  const realPath = url.split("?")[0];
+  if (realPath === void 0) {
+    throw new TypeError("Path is undefined");
+  }
+  const modelName = Object.keys(models).find((name) => {
+    const routeName = models[name];
+    const camelCaseModel = ensureCamelCase(routeName);
+    return new RegExp(`(${routeName}|${camelCaseModel}$)|(${routeName}|${camelCaseModel}/)`, "g").test(realPath);
+  });
+  if (modelName === void 0) {
+    throw new Error(`Couldn't find model ${modelName} name for url ${url}`);
+  }
+  return {
+    modelName,
+    resourceName: models[modelName]
+  };
+};
+
+const getRouteType = (method, url, resourceName) => {
+  const realPath = url.split("?")[0];
+  if (realPath === void 0) {
+    throw new TypeError("Path is undefined");
+  }
+  if (!realPath.includes(`/${resourceName}`)) {
+    throw new Error(`invalid resource name '${resourceName}' for route '${realPath}'`);
+  }
+  const entityMatcher = match(`/*placeholder/${resourceName}{/:id}`, { decode: decodeURIComponent });
+  const simpleMatcher = match(`/*placeholder/${resourceName}`, {
+    decode: decodeURIComponent
+  });
+  switch (method) {
+    case "DELETE": {
+      const pathMatch = entityMatcher(realPath);
+      if (typeof pathMatch === "object" && pathMatch.params.id) {
+        return {
+          resourceId: pathMatch.params.id,
+          routeType: RouteType.DELETE
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    case "GET": {
+      const pathMatch = entityMatcher(realPath);
+      console.log(pathMatch);
+      if (typeof pathMatch === "object" && pathMatch.params?.id) {
+        return {
+          resourceId: pathMatch.params.id,
+          routeType: RouteType.READ_ONE
+        };
+      }
+      return {
+        routeType: RouteType.READ_ALL
+      };
+    }
+    case "PATCH":
+    case "PUT": {
+      const pathMatch = entityMatcher(realPath);
+      if (typeof pathMatch === "object" && pathMatch.params.id) {
+        return {
+          resourceId: pathMatch.params.id,
+          routeType: RouteType.UPDATE
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    case "POST": {
+      const pathMatch = simpleMatcher(realPath);
+      if (pathMatch) {
+        return {
+          routeType: RouteType.CREATE
+        };
+      }
+      return {
+        routeType: null
+      };
+    }
+    default: {
+      return {
+        routeType: null
+      };
+    }
+  }
+};
+
+const adapterMethods = ["create", "delete", "getAll", "getOne", "parseQuery", "update", "getPaginationData", "getModels"];
+const validateAdapterMethods = (adapter) => {
+  adapterMethods.forEach((method) => {
+    if (!adapter[method]) {
+      throw createHttpError(500, `Adapter must implement the "${method}" method.`);
+    }
+  });
+};
+
+async function baseHandler(responseExecutor, finalExecutor, adapter, options) {
+  try {
+    validateAdapterMethods(adapter);
+  } catch (error_) {
+    const error = error_;
+    throw new ApiError(error.statusCode, error.message);
+  }
+  await adapter.init?.();
+  const config = {
+    formatResourceId,
+    pagination: {
+      perPage: 20
+    },
+    ...options
+  };
+  const routeNames = await adapter.mapModelsToRouteNames?.();
+  const modelRoutes = {};
+  adapter.getModels().forEach((modelName) => {
+    modelRoutes[modelName] = config.models?.[modelName]?.name ?? routeNames?.[modelName] ?? modelName;
+  });
+  return async (request, responseOrContext) => {
+    const { modelName, resourceName } = getResourceNameFromUrl(request.url, modelRoutes);
+    if (!resourceName) {
+      {
+        const mappedModels = await adapter.mapModelsToRouteNames?.();
+        if (typeof mappedModels === "object") {
+          throw createHttpError(404, `Resource not found, possible models: ${Object.values(mappedModels).join(", ")}`);
+        }
+      }
+      throw createHttpError(404, `Resource not found: ${request.url}`);
+    }
+    const { resourceId, routeType } = getRouteType(request.method, request.url, resourceName);
+    if (routeType === null) {
+      throw createHttpError(404, `Route not found: ${request.url}`);
+    }
+    const modelConfig = options?.models?.[modelName];
+    const accessibleRoutes = getAccessibleRoutes(modelConfig?.only, modelConfig?.exclude, options?.exposeStrategy ?? "all");
+    if (!accessibleRoutes.includes(routeType)) {
+      throw createHttpError(404, `Route not found: ${request.url}`);
+    }
+    try {
+      const resourceIdFormatted = modelConfig?.formatResourceId?.(resourceId) ?? config.formatResourceId(resourceId);
+      await adapter.connect?.();
+      const parsedQuery = parseQuery(`https://${request.headers.host?.replace(/\/$/u, "")}/${request.url}`);
+      const parameters = {
+        adapter,
+        query: adapter.parseQuery(modelName, parsedQuery),
+        resourceName: modelName
+      };
+      try {
+        let responseConfig;
+        switch (routeType) {
+          case RouteType.CREATE: {
+            responseConfig = await (config.handlers?.create ?? createHandler)({
+              ...parameters,
+              request
+            });
+            break;
+          }
+          case RouteType.DELETE: {
+            responseConfig = await (config.handlers?.delete ?? deleteHandler)({
+              ...parameters,
+              resourceId: resourceIdFormatted
+            });
+            break;
+          }
+          case RouteType.READ_ALL: {
+            responseConfig = await (config.handlers?.list ?? listHandler)({
+              ...parameters,
+              pagination: config.pagination,
+              query: {
+                ...parameters.query,
+                limit: parsedQuery.limit ? Number(parsedQuery.limit) : void 0,
+                page: parsedQuery.page ? Number(parsedQuery.page) : void 0
+              }
+            });
+            break;
+          }
+          case RouteType.READ_ONE: {
+            responseConfig = await (config.handlers?.get ?? readHandler)({
+              ...parameters,
+              resourceId: resourceIdFormatted
+            });
+            break;
+          }
+          case RouteType.UPDATE: {
+            responseConfig = await (config.handlers?.update ?? updateHandler)({
+              ...parameters,
+              request,
+              resourceId: resourceIdFormatted
+            });
+            break;
+          }
+          default: {
+            responseConfig = {
+              data: "Method not found",
+              status: 404
+            };
+          }
+        }
+        await responseExecutor(responseOrContext, responseConfig);
+      } catch (error) {
+        if (adapter.handleError && !(error instanceof ApiError)) {
+          adapter.handleError(error);
+        } else {
+          throw error;
+        }
+      }
+    } finally {
+      await adapter.disconnect?.();
+      await finalExecutor(responseOrContext);
+    }
+  };
+}
+
+export { baseHandler as b };

package/dist/packem_shared/edgeHandler-B4JJXPUI.mjs

@@ -0,0 +1,16 @@
+import { b as baseHandler } from './base-crud-handler-DgrOMhoH.mjs';
+
+const handler = async (adapter, options) => await baseHandler(
+  async (_, responseConfig) => Response.json(responseConfig.data, {
+    headers: {
+      "content-type": "application/json; charset=utf-8"
+    },
+    status: responseConfig.status
+  }),
+  async () => {
+  },
+  adapter,
+  options
+);
+
+export { handler as default };

package/dist/packem_shared/edgeHandler-CDFgDdrG.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const baseCrudHandler = require('./base-crud-handler-B3eCO4up.cjs');
+
+const handler = async (adapter, options) => await baseCrudHandler.baseHandler(
+  async (_, responseConfig) => Response.json(responseConfig.data, {
+    headers: {
+      "content-type": "application/json; charset=utf-8"
+    },
+    status: responseConfig.status
+  }),
+  async () => {
+  },
+  adapter,
+  options
+);
+
+module.exports = handler;

package/dist/packem_shared/get-accessible-routes-C6NF9Iry.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const RouteType = require('./RouteType-Bk3uAK0x.cjs');
+
+const getAccessibleRoutes = (only, exclude, defaultExposeStrategy = "all") => {
+  let accessibleRoutes = defaultExposeStrategy === "none" ? [] : [RouteType.RouteType.READ_ALL, RouteType.RouteType.READ_ONE, RouteType.RouteType.UPDATE, RouteType.RouteType.DELETE, RouteType.RouteType.CREATE];
+  if (Array.isArray(only)) {
+    accessibleRoutes = only;
+  }
+  if (exclude?.length) {
+    accessibleRoutes = accessibleRoutes.filter((element) => !exclude.includes(element));
+  }
+  return accessibleRoutes;
+};
+
+exports.getAccessibleRoutes = getAccessibleRoutes;

package/dist/packem_shared/get-accessible-routes-sV5SDdFn.mjs

@@ -0,0 +1,14 @@
+import { RouteType } from './RouteType-CB2xrWdf.mjs';
+
+const getAccessibleRoutes = (only, exclude, defaultExposeStrategy = "all") => {
+  let accessibleRoutes = defaultExposeStrategy === "none" ? [] : [RouteType.READ_ALL, RouteType.READ_ONE, RouteType.UPDATE, RouteType.DELETE, RouteType.CREATE];
+  if (Array.isArray(only)) {
+    accessibleRoutes = only;
+  }
+  if (exclude?.length) {
+    accessibleRoutes = accessibleRoutes.filter((element) => !exclude.includes(element));
+  }
+  return accessibleRoutes;
+};
+
+export { getAccessibleRoutes as g };

package/dist/packem_shared/models-to-route-names-CdwsK0V1.mjs

@@ -0,0 +1,9 @@
+const modelsToRouteNames = (mappingsMap, models) => {
+  const routesMap = {};
+  models.forEach((model) => {
+    routesMap[model] = mappingsMap[model].plural;
+  });
+  return routesMap;
+};
+
+export { modelsToRouteNames as m };

package/dist/packem_shared/models-to-route-names-Dv94PzhE.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const modelsToRouteNames = (mappingsMap, models) => {
+  const routesMap = {};
+  models.forEach((model) => {
+    routesMap[model] = mappingsMap[model].plural;
+  });
+  return routesMap;
+};
+
+exports.modelsToRouteNames = modelsToRouteNames;