s3db.js 12.2.0 → 12.2.2

package/dist/s3db.es.js

@@ -1,9 +1,6 @@
 import crypto$1, { createHash } from 'crypto';
 import { customAlphabet, urlAlphabet } from 'nanoid';
 import EventEmitter from 'events';
-import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
-import { swaggerUI } from '@hono/swagger-ui';
 import { mkdir, copyFile, unlink, stat, access, readdir, writeFile, readFile, rm, watch } from 'fs/promises';
 import fs, { createReadStream, createWriteStream, realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$2, lstatSync, existsSync } from 'fs';
 import { pipeline } from 'stream/promises';
@@ -2451,1968 +2448,6 @@ const PluginObject = {
   }
 };
 
-function success(data, options = {}) {
-  const { status = 200, meta = {} } = options;
-  return {
-    success: true,
-    data,
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      ...meta
-    },
-    _status: status
-  };
-}
-function error(error2, options = {}) {
-  const { status = 500, code = "INTERNAL_ERROR", details = {} } = options;
-  const errorMessage = error2 instanceof Error ? error2.message : error2;
-  const errorStack = error2 instanceof Error && process.env.NODE_ENV !== "production" ? error2.stack : void 0;
-  return {
-    success: false,
-    error: {
-      message: errorMessage,
-      code,
-      details,
-      stack: errorStack
-    },
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    _status: status
-  };
-}
-function list(items, pagination = {}) {
-  const { total, page, pageSize, pageCount } = pagination;
-  return {
-    success: true,
-    data: items,
-    pagination: {
-      total: total || items.length,
-      page: page || 1,
-      pageSize: pageSize || items.length,
-      pageCount: pageCount || 1
-    },
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    _status: 200
-  };
-}
-function created(data, location) {
-  return {
-    success: true,
-    data,
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      location
-    },
-    _status: 201
-  };
-}
-function noContent() {
-  return {
-    success: true,
-    data: null,
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    _status: 204
-  };
-}
-function notFound(resource, id) {
-  return error(`${resource} with id '${id}' not found`, {
-    status: 404,
-    code: "NOT_FOUND",
-    details: { resource, id }
-  });
-}
-function payloadTooLarge(size, limit) {
-  return error("Request payload too large", {
-    status: 413,
-    code: "PAYLOAD_TOO_LARGE",
-    details: {
-      receivedSize: size,
-      maxSize: limit,
-      receivedMB: (size / 1024 / 1024).toFixed(2),
-      maxMB: (limit / 1024 / 1024).toFixed(2)
-    }
-  });
-}
-
-const errorStatusMap = {
-  "ValidationError": 400,
-  "InvalidResourceItem": 400,
-  "ResourceNotFound": 404,
-  "NoSuchKey": 404,
-  "NoSuchBucket": 404,
-  "PartitionError": 400,
-  "CryptoError": 500,
-  "SchemaError": 400,
-  "QueueError": 500,
-  "ResourceError": 500
-};
-function getStatusFromError(err) {
-  if (err.name && errorStatusMap[err.name]) {
-    return errorStatusMap[err.name];
-  }
-  if (err.constructor && err.constructor.name && errorStatusMap[err.constructor.name]) {
-    return errorStatusMap[err.constructor.name];
-  }
-  if (err.message) {
-    if (err.message.includes("not found") || err.message.includes("does not exist")) {
-      return 404;
-    }
-    if (err.message.includes("validation") || err.message.includes("invalid")) {
-      return 400;
-    }
-    if (err.message.includes("unauthorized") || err.message.includes("authentication")) {
-      return 401;
-    }
-    if (err.message.includes("forbidden") || err.message.includes("permission")) {
-      return 403;
-    }
-  }
-  return 500;
-}
-function errorHandler(err, c) {
-  const status = getStatusFromError(err);
-  const code = err.name || "INTERNAL_ERROR";
-  const details = {};
-  if (err.resource) details.resource = err.resource;
-  if (err.bucket) details.bucket = err.bucket;
-  if (err.key) details.key = err.key;
-  if (err.operation) details.operation = err.operation;
-  if (err.suggestion) details.suggestion = err.suggestion;
-  if (err.availableResources) details.availableResources = err.availableResources;
-  const response = error(err, {
-    status,
-    code,
-    details
-  });
-  if (status >= 500) {
-    console.error("[API Plugin] Error:", {
-      message: err.message,
-      code,
-      status,
-      stack: err.stack,
-      details
-    });
-  } else if (status >= 400 && status < 500 && c.get("verbose")) {
-    console.warn("[API Plugin] Client error:", {
-      message: err.message,
-      code,
-      status,
-      details
-    });
-  }
-  return c.json(response, response._status);
-}
-function asyncHandler(fn) {
-  return async (c) => {
-    try {
-      return await fn(c);
-    } catch (err) {
-      return errorHandler(err, c);
-    }
-  };
-}
-
-function createResourceRoutes(resource, version, config = {}) {
-  const app = new Hono();
-  const {
-    methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
-    customMiddleware = [],
-    enableValidation = true
-  } = config;
-  const resourceName = resource.name;
-  const basePath = `/${version}/${resourceName}`;
-  customMiddleware.forEach((middleware) => {
-    app.use("*", middleware);
-  });
-  if (methods.includes("GET")) {
-    app.get("/", asyncHandler(async (c) => {
-      const query = c.req.query();
-      const limit = parseInt(query.limit) || 100;
-      const offset = parseInt(query.offset) || 0;
-      const partition = query.partition;
-      const partitionValues = query.partitionValues ? JSON.parse(query.partitionValues) : void 0;
-      const reservedKeys = ["limit", "offset", "partition", "partitionValues", "sort"];
-      const filters = {};
-      for (const [key, value] of Object.entries(query)) {
-        if (!reservedKeys.includes(key)) {
-          try {
-            filters[key] = JSON.parse(value);
-          } catch {
-            filters[key] = value;
-          }
-        }
-      }
-      let items;
-      let total;
-      if (Object.keys(filters).length > 0) {
-        items = await resource.query(filters, { limit: limit + offset });
-        items = items.slice(offset, offset + limit);
-        total = items.length;
-      } else if (partition && partitionValues) {
-        items = await resource.listPartition({
-          partition,
-          partitionValues,
-          limit: limit + offset
-        });
-        items = items.slice(offset, offset + limit);
-        total = items.length;
-      } else {
-        items = await resource.list({ limit: limit + offset });
-        items = items.slice(offset, offset + limit);
-        total = items.length;
-      }
-      const response = list(items, {
-        total,
-        page: Math.floor(offset / limit) + 1,
-        pageSize: limit,
-        pageCount: Math.ceil(total / limit)
-      });
-      c.header("X-Total-Count", total.toString());
-      c.header("X-Page-Count", Math.ceil(total / limit).toString());
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("GET")) {
-    app.get("/:id", asyncHandler(async (c) => {
-      const id = c.req.param("id");
-      const query = c.req.query();
-      const partition = query.partition;
-      const partitionValues = query.partitionValues ? JSON.parse(query.partitionValues) : void 0;
-      let item;
-      if (partition && partitionValues) {
-        item = await resource.getFromPartition({
-          id,
-          partitionName: partition,
-          partitionValues
-        });
-      } else {
-        item = await resource.get(id);
-      }
-      if (!item) {
-        const response2 = notFound(resourceName, id);
-        return c.json(response2, response2._status);
-      }
-      const response = success(item);
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("POST")) {
-    app.post("/", asyncHandler(async (c) => {
-      const data = await c.req.json();
-      const item = await resource.insert(data);
-      const location = `${basePath}/${item.id}`;
-      const response = created(item, location);
-      c.header("Location", location);
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("PUT")) {
-    app.put("/:id", asyncHandler(async (c) => {
-      const id = c.req.param("id");
-      const data = await c.req.json();
-      const existing = await resource.get(id);
-      if (!existing) {
-        const response2 = notFound(resourceName, id);
-        return c.json(response2, response2._status);
-      }
-      const updated = await resource.update(id, data);
-      const response = success(updated);
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("PATCH")) {
-    app.patch("/:id", asyncHandler(async (c) => {
-      const id = c.req.param("id");
-      const data = await c.req.json();
-      const existing = await resource.get(id);
-      if (!existing) {
-        const response2 = notFound(resourceName, id);
-        return c.json(response2, response2._status);
-      }
-      const merged = { ...existing, ...data, id };
-      const updated = await resource.update(id, merged);
-      const response = success(updated);
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("DELETE")) {
-    app.delete("/:id", asyncHandler(async (c) => {
-      const id = c.req.param("id");
-      const existing = await resource.get(id);
-      if (!existing) {
-        const response2 = notFound(resourceName, id);
-        return c.json(response2, response2._status);
-      }
-      await resource.delete(id);
-      const response = noContent();
-      return c.json(response, response._status);
-    }));
-  }
-  if (methods.includes("HEAD")) {
-    app.on("HEAD", "/", asyncHandler(async (c) => {
-      const total = await resource.count();
-      const allItems = await resource.list({ limit: 1e3 });
-      const stats = {
-        total,
-        version: resource.config?.currentVersion || resource.version || "v1"
-      };
-      c.header("X-Total-Count", total.toString());
-      c.header("X-Resource-Version", stats.version);
-      c.header("X-Schema-Fields", Object.keys(resource.config?.attributes || {}).length.toString());
-      return c.body(null, 200);
-    }));
-    app.on("HEAD", "/:id", asyncHandler(async (c) => {
-      const id = c.req.param("id");
-      const item = await resource.get(id);
-      if (!item) {
-        return c.body(null, 404);
-      }
-      if (item.updatedAt) {
-        c.header("Last-Modified", new Date(item.updatedAt).toUTCString());
-      }
-      return c.body(null, 200);
-    }));
-  }
-  if (methods.includes("OPTIONS")) {
-    app.options("/", asyncHandler(async (c) => {
-      c.header("Allow", methods.join(", "));
-      const total = await resource.count();
-      const schema = resource.config?.attributes || {};
-      const version2 = resource.config?.currentVersion || resource.version || "v1";
-      const metadata = {
-        resource: resourceName,
-        version: version2,
-        totalRecords: total,
-        allowedMethods: methods,
-        schema: Object.entries(schema).map(([name, def]) => ({
-          name,
-          type: typeof def === "string" ? def.split("|")[0] : def.type,
-          rules: typeof def === "string" ? def.split("|").slice(1) : []
-        })),
-        endpoints: {
-          list: `/${version2}/${resourceName}`,
-          get: `/${version2}/${resourceName}/:id`,
-          create: `/${version2}/${resourceName}`,
-          update: `/${version2}/${resourceName}/:id`,
-          delete: `/${version2}/${resourceName}/:id`
-        },
-        queryParameters: {
-          limit: "number (1-1000, default: 100)",
-          offset: "number (min: 0, default: 0)",
-          partition: "string (partition name)",
-          partitionValues: "JSON string",
-          "[any field]": "any (filter by field value)"
-        }
-      };
-      return c.json(metadata);
-    }));
-    app.options("/:id", (c) => {
-      c.header("Allow", methods.filter((m) => m !== "POST").join(", "));
-      return c.body(null, 204);
-    });
-  }
-  return app;
-}
-function createRelationalRoutes(sourceResource, relationName, relationConfig, version) {
-  const app = new Hono();
-  const resourceName = sourceResource.name;
-  const relatedResourceName = relationConfig.resource;
-  app.get("/:id", asyncHandler(async (c) => {
-    const id = c.req.param("id");
-    const query = c.req.query();
-    const source = await sourceResource.get(id);
-    if (!source) {
-      const response = notFound(resourceName, id);
-      return c.json(response, response._status);
-    }
-    const result = await sourceResource.get(id, {
-      include: [relationName]
-    });
-    const relatedData = result[relationName];
-    if (!relatedData) {
-      if (relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany") {
-        const response = list([], {
-          total: 0,
-          page: 1,
-          pageSize: 100,
-          pageCount: 0
-        });
-        return c.json(response, response._status);
-      } else {
-        const response = notFound(relatedResourceName, "related resource");
-        return c.json(response, response._status);
-      }
-    }
-    if (relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany") {
-      const items = Array.isArray(relatedData) ? relatedData : [relatedData];
-      const limit = parseInt(query.limit) || 100;
-      const offset = parseInt(query.offset) || 0;
-      const paginatedItems = items.slice(offset, offset + limit);
-      const response = list(paginatedItems, {
-        total: items.length,
-        page: Math.floor(offset / limit) + 1,
-        pageSize: limit,
-        pageCount: Math.ceil(items.length / limit)
-      });
-      c.header("X-Total-Count", items.length.toString());
-      c.header("X-Page-Count", Math.ceil(items.length / limit).toString());
-      return c.json(response, response._status);
-    } else {
-      const response = success(relatedData);
-      return c.json(response, response._status);
-    }
-  }));
-  return app;
-}
-
-function mapFieldTypeToOpenAPI(fieldType) {
-  const type = fieldType.split("|")[0].trim();
-  const typeMap = {
-    "string": { type: "string" },
-    "number": { type: "number" },
-    "integer": { type: "integer" },
-    "boolean": { type: "boolean" },
-    "array": { type: "array", items: { type: "string" } },
-    "object": { type: "object" },
-    "json": { type: "object" },
-    "secret": { type: "string", format: "password" },
-    "email": { type: "string", format: "email" },
-    "url": { type: "string", format: "uri" },
-    "date": { type: "string", format: "date" },
-    "datetime": { type: "string", format: "date-time" },
-    "ip4": { type: "string", format: "ipv4", description: "IPv4 address" },
-    "ip6": { type: "string", format: "ipv6", description: "IPv6 address" },
-    "embedding": { type: "array", items: { type: "number" }, description: "Vector embedding" }
-  };
-  if (type.startsWith("embedding:")) {
-    const length = parseInt(type.split(":")[1]);
-    return {
-      type: "array",
-      items: { type: "number" },
-      minItems: length,
-      maxItems: length,
-      description: `Vector embedding (${length} dimensions)`
-    };
-  }
-  return typeMap[type] || { type: "string" };
-}
-function extractValidationRules(fieldDef) {
-  const rules = {};
-  const parts = fieldDef.split("|");
-  for (const part of parts) {
-    const [rule, value] = part.split(":").map((s) => s.trim());
-    switch (rule) {
-      case "required":
-        rules.required = true;
-        break;
-      case "min":
-        rules.minimum = parseFloat(value);
-        break;
-      case "max":
-        rules.maximum = parseFloat(value);
-        break;
-      case "minlength":
-        rules.minLength = parseInt(value);
-        break;
-      case "maxlength":
-        rules.maxLength = parseInt(value);
-        break;
-      case "pattern":
-        rules.pattern = value;
-        break;
-      case "enum":
-        rules.enum = value.split(",").map((v) => v.trim());
-        break;
-      case "default":
-        rules.default = value;
-        break;
-    }
-  }
-  return rules;
-}
-function generateResourceSchema(resource) {
-  const properties = {};
-  const required = [];
-  const attributes = resource.config?.attributes || resource.attributes || {};
-  const resourceDescription = resource.config?.description;
-  const attributeDescriptions = typeof resourceDescription === "object" ? resourceDescription.attributes || {} : {};
-  properties.id = {
-    type: "string",
-    description: "Unique identifier for the resource",
-    example: "2_gDTpeU6EI0e8B92n_R3Y",
-    readOnly: true
-  };
-  for (const [fieldName, fieldDef] of Object.entries(attributes)) {
-    if (typeof fieldDef === "object" && fieldDef.type) {
-      const baseType = mapFieldTypeToOpenAPI(fieldDef.type);
-      properties[fieldName] = {
-        ...baseType,
-        description: fieldDef.description || attributeDescriptions[fieldName] || void 0
-      };
-      if (fieldDef.required) {
-        required.push(fieldName);
-      }
-      if (fieldDef.type === "object" && fieldDef.props) {
-        properties[fieldName].properties = {};
-        for (const [propName, propDef] of Object.entries(fieldDef.props)) {
-          const propType = typeof propDef === "string" ? propDef : propDef.type;
-          properties[fieldName].properties[propName] = mapFieldTypeToOpenAPI(propType);
-        }
-      }
-      if (fieldDef.type === "array" && fieldDef.items) {
-        properties[fieldName].items = mapFieldTypeToOpenAPI(fieldDef.items);
-      }
-    } else if (typeof fieldDef === "string") {
-      const baseType = mapFieldTypeToOpenAPI(fieldDef);
-      const rules = extractValidationRules(fieldDef);
-      properties[fieldName] = {
-        ...baseType,
-        ...rules,
-        description: attributeDescriptions[fieldName] || void 0
-      };
-      if (rules.required) {
-        required.push(fieldName);
-        delete properties[fieldName].required;
-      }
-    }
-  }
-  return {
-    type: "object",
-    properties,
-    required: required.length > 0 ? required : void 0
-  };
-}
-function generateResourcePaths(resource, version, config = {}) {
-  const resourceName = resource.name;
-  const basePath = `/${version}/${resourceName}`;
-  const schema = generateResourceSchema(resource);
-  const methods = config.methods || ["GET", "POST", "PUT", "PATCH", "DELETE"];
-  const authMethods = config.auth || [];
-  const requiresAuth = authMethods && authMethods.length > 0;
-  const paths = {};
-  const security = [];
-  if (requiresAuth) {
-    if (authMethods.includes("jwt")) security.push({ bearerAuth: [] });
-    if (authMethods.includes("apiKey")) security.push({ apiKeyAuth: [] });
-    if (authMethods.includes("basic")) security.push({ basicAuth: [] });
-  }
-  const partitions = resource.config?.options?.partitions || resource.config?.partitions || resource.partitions || {};
-  const partitionNames = Object.keys(partitions);
-  const hasPartitions = partitionNames.length > 0;
-  let partitionDescription = "Partition name for filtering";
-  let partitionValuesDescription = "Partition values as JSON string";
-  let partitionExample = void 0;
-  let partitionValuesExample = void 0;
-  if (hasPartitions) {
-    const partitionDocs = partitionNames.map((name) => {
-      const partition = partitions[name];
-      const fields = Object.keys(partition.fields || {});
-      const fieldTypes = Object.entries(partition.fields || {}).map(([field, type]) => `${field}: ${type}`).join(", ");
-      return `- **${name}**: Filters by ${fields.join(", ")} (${fieldTypes})`;
-    }).join("\n");
-    partitionDescription = `Available partitions:
-${partitionDocs}`;
-    const examplePartition = partitionNames[0];
-    const exampleFields = partitions[examplePartition]?.fields || {};
-    Object.entries(exampleFields).map(([field, type]) => `"${field}": <${type} value>`).join(", ");
-    partitionValuesDescription = `Partition field values as JSON string. Must match the structure of the selected partition.
-
-Example for "${examplePartition}" partition: \`{"${Object.keys(exampleFields)[0]}": "value"}\``;
-    partitionExample = examplePartition;
-    const firstField = Object.keys(exampleFields)[0];
-    const firstFieldType = exampleFields[firstField];
-    let exampleValue = "example";
-    if (firstFieldType === "number" || firstFieldType === "integer") {
-      exampleValue = 123;
-    } else if (firstFieldType === "boolean") {
-      exampleValue = true;
-    }
-    partitionValuesExample = JSON.stringify({ [firstField]: exampleValue });
-  }
-  const attributeQueryParams = [];
-  if (hasPartitions) {
-    const partitionFieldsSet = /* @__PURE__ */ new Set();
-    for (const [partitionName, partition] of Object.entries(partitions)) {
-      const fields = partition.fields || {};
-      for (const fieldName of Object.keys(fields)) {
-        partitionFieldsSet.add(fieldName);
-      }
-    }
-    const attributes = resource.config?.attributes || resource.attributes || {};
-    for (const fieldName of partitionFieldsSet) {
-      const fieldDef = attributes[fieldName];
-      if (!fieldDef) continue;
-      let fieldType;
-      if (typeof fieldDef === "object" && fieldDef.type) {
-        fieldType = fieldDef.type;
-      } else if (typeof fieldDef === "string") {
-        fieldType = fieldDef.split("|")[0].trim();
-      } else {
-        fieldType = "string";
-      }
-      const openAPIType = mapFieldTypeToOpenAPI(fieldType);
-      attributeQueryParams.push({
-        name: fieldName,
-        in: "query",
-        description: `Filter by ${fieldName} field (indexed via partitions for efficient querying). Value will be parsed as JSON if possible, otherwise treated as string.`,
-        required: false,
-        schema: openAPIType
-      });
-    }
-  }
-  if (methods.includes("GET")) {
-    paths[basePath] = {
-      get: {
-        tags: [resourceName],
-        summary: `List ${resourceName}`,
-        description: `Retrieve a paginated list of ${resourceName}. Supports filtering by passing any resource field as a query parameter (e.g., ?status=active&year=2024). Values are parsed as JSON if possible, otherwise treated as strings.
-
-**Pagination**: Use \`limit\` and \`offset\` to paginate results. For example:
-- First page (10 items): \`?limit=10&offset=0\`
-- Second page: \`?limit=10&offset=10\`
-- Third page: \`?limit=10&offset=20\`
-
-The response includes pagination metadata in the \`pagination\` object with total count and page information.${hasPartitions ? "\n\n**Partitioning**: This resource supports partitioned queries for optimized filtering. Use the `partition` and `partitionValues` parameters together." : ""}`,
-        parameters: [
-          {
-            name: "limit",
-            in: "query",
-            description: "Maximum number of items to return per page (page size)",
-            schema: { type: "integer", default: 100, minimum: 1, maximum: 1e3 },
-            example: 10
-          },
-          {
-            name: "offset",
-            in: "query",
-            description: "Number of items to skip before starting to return results. Use for pagination: offset = (page - 1) * limit",
-            schema: { type: "integer", default: 0, minimum: 0 },
-            example: 0
-          },
-          ...hasPartitions ? [
-            {
-              name: "partition",
-              in: "query",
-              description: partitionDescription,
-              schema: {
-                type: "string",
-                enum: partitionNames
-              },
-              example: partitionExample
-            },
-            {
-              name: "partitionValues",
-              in: "query",
-              description: partitionValuesDescription,
-              schema: { type: "string" },
-              example: partitionValuesExample
-            }
-          ] : [],
-          ...attributeQueryParams
-        ],
-        responses: {
-          200: {
-            description: "Successful response",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    success: { type: "boolean", example: true },
-                    data: {
-                      type: "array",
-                      items: schema
-                    },
-                    pagination: {
-                      type: "object",
-                      description: "Pagination metadata for the current request",
-                      properties: {
-                        total: {
-                          type: "integer",
-                          description: "Total number of items available",
-                          example: 150
-                        },
-                        page: {
-                          type: "integer",
-                          description: "Current page number (1-indexed)",
-                          example: 1
-                        },
-                        pageSize: {
-                          type: "integer",
-                          description: "Number of items per page (same as limit parameter)",
-                          example: 10
-                        },
-                        pageCount: {
-                          type: "integer",
-                          description: "Total number of pages available",
-                          example: 15
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            },
-            headers: {
-              "X-Total-Count": {
-                description: "Total number of records",
-                schema: { type: "integer" }
-              },
-              "X-Page-Count": {
-                description: "Total number of pages",
-                schema: { type: "integer" }
-              }
-            }
-          }
-        },
-        security: security.length > 0 ? security : void 0
-      }
-    };
-  }
-  if (methods.includes("GET")) {
-    paths[`${basePath}/{id}`] = {
-      get: {
-        tags: [resourceName],
-        summary: `Get ${resourceName} by ID`,
-        description: `Retrieve a single ${resourceName} by its ID${hasPartitions ? ". Optionally specify a partition for more efficient retrieval." : ""}`,
-        parameters: [
-          {
-            name: "id",
-            in: "path",
-            required: true,
-            description: `${resourceName} ID`,
-            schema: { type: "string" }
-          },
-          ...hasPartitions ? [
-            {
-              name: "partition",
-              in: "query",
-              description: partitionDescription,
-              schema: {
-                type: "string",
-                enum: partitionNames
-              },
-              example: partitionExample
-            },
-            {
-              name: "partitionValues",
-              in: "query",
-              description: partitionValuesDescription,
-              schema: { type: "string" },
-              example: partitionValuesExample
-            }
-          ] : []
-        ],
-        responses: {
-          200: {
-            description: "Successful response",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    success: { type: "boolean", example: true },
-                    data: schema
-                  }
-                }
-              }
-            }
-          },
-          404: {
-            description: "Resource not found",
-            content: {
-              "application/json": {
-                schema: { $ref: "#/components/schemas/Error" }
-              }
-            }
-          }
-        },
-        security: security.length > 0 ? security : void 0
-      }
-    };
-  }
-  if (methods.includes("POST")) {
-    if (!paths[basePath]) paths[basePath] = {};
-    paths[basePath].post = {
-      tags: [resourceName],
-      summary: `Create ${resourceName}`,
-      description: `Create a new ${resourceName}`,
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema
-          }
-        }
-      },
-      responses: {
-        201: {
-          description: "Resource created successfully",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: schema
-                }
-              }
-            }
-          },
-          headers: {
-            Location: {
-              description: "URL of the created resource",
-              schema: { type: "string" }
-            }
-          }
-        },
-        400: {
-          description: "Validation error",
-          content: {
-            "application/json": {
-              schema: { $ref: "#/components/schemas/ValidationError" }
-            }
-          }
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-  }
-  if (methods.includes("PUT")) {
-    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
-    paths[`${basePath}/{id}`].put = {
-      tags: [resourceName],
-      summary: `Update ${resourceName} (full)`,
-      description: `Fully update a ${resourceName}`,
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: "Resource updated successfully",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: schema
-                }
-              }
-            }
-          }
-        },
-        404: {
-          description: "Resource not found",
-          content: {
-            "application/json": {
-              schema: { $ref: "#/components/schemas/Error" }
-            }
-          }
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-  }
-  if (methods.includes("PATCH")) {
-    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
-    paths[`${basePath}/{id}`].patch = {
-      tags: [resourceName],
-      summary: `Update ${resourceName} (partial)`,
-      description: `Partially update a ${resourceName}`,
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              ...schema,
-              required: void 0
-              // Partial updates don't require all fields
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: "Resource updated successfully",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: schema
-                }
-              }
-            }
-          }
-        },
-        404: {
-          description: "Resource not found",
-          content: {
-            "application/json": {
-              schema: { $ref: "#/components/schemas/Error" }
-            }
-          }
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-  }
-  if (methods.includes("DELETE")) {
-    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
-    paths[`${basePath}/{id}`].delete = {
-      tags: [resourceName],
-      summary: `Delete ${resourceName}`,
-      description: `Delete a ${resourceName} by ID`,
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        204: {
-          description: "Resource deleted successfully"
-        },
-        404: {
-          description: "Resource not found",
-          content: {
-            "application/json": {
-              schema: { $ref: "#/components/schemas/Error" }
-            }
-          }
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-  }
-  if (methods.includes("HEAD")) {
-    if (!paths[basePath]) paths[basePath] = {};
-    paths[basePath].head = {
-      tags: [resourceName],
-      summary: `Get ${resourceName} statistics`,
-      description: `Get statistics about ${resourceName} collection without retrieving data. Returns statistics in response headers.`,
-      responses: {
-        200: {
-          description: "Statistics retrieved successfully",
-          headers: {
-            "X-Total-Count": {
-              description: "Total number of records",
-              schema: { type: "integer" }
-            },
-            "X-Resource-Version": {
-              description: "Current resource version",
-              schema: { type: "string" }
-            },
-            "X-Schema-Fields": {
-              description: "Number of schema fields",
-              schema: { type: "integer" }
-            }
-          }
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
-    paths[`${basePath}/{id}`].head = {
-      tags: [resourceName],
-      summary: `Check if ${resourceName} exists`,
-      description: `Check if a ${resourceName} exists without retrieving its data`,
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "Resource exists",
-          headers: {
-            "Last-Modified": {
-              description: "Last modification date",
-              schema: { type: "string", format: "date-time" }
-            }
-          }
-        },
-        404: {
-          description: "Resource not found"
-        }
-      },
-      security: security.length > 0 ? security : void 0
-    };
-  }
-  if (methods.includes("OPTIONS")) {
-    if (!paths[basePath]) paths[basePath] = {};
-    paths[basePath].options = {
-      tags: [resourceName],
-      summary: `Get ${resourceName} metadata`,
-      description: `Get complete metadata about ${resourceName} resource including schema, allowed methods, endpoints, and query parameters`,
-      responses: {
-        200: {
-          description: "Metadata retrieved successfully",
-          headers: {
-            "Allow": {
-              description: "Allowed HTTP methods",
-              schema: { type: "string", example: "GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS" }
-            }
-          },
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  resource: { type: "string" },
-                  version: { type: "string" },
-                  totalRecords: { type: "integer" },
-                  allowedMethods: {
-                    type: "array",
-                    items: { type: "string" }
-                  },
-                  schema: {
-                    type: "array",
-                    items: {
-                      type: "object",
-                      properties: {
-                        name: { type: "string" },
-                        type: { type: "string" },
-                        rules: { type: "array", items: { type: "string" } }
-                      }
-                    }
-                  },
-                  endpoints: {
-                    type: "object",
-                    properties: {
-                      list: { type: "string" },
-                      get: { type: "string" },
-                      create: { type: "string" },
-                      update: { type: "string" },
-                      delete: { type: "string" }
-                    }
-                  },
-                  queryParameters: { type: "object" }
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
-    paths[`${basePath}/{id}`].options = {
-      tags: [resourceName],
-      summary: `Get allowed methods for ${resourceName} item`,
-      description: `Get allowed HTTP methods for individual ${resourceName} operations`,
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        204: {
-          description: "Methods retrieved successfully",
-          headers: {
-            "Allow": {
-              description: "Allowed HTTP methods",
-              schema: { type: "string", example: "GET, PUT, PATCH, DELETE, HEAD, OPTIONS" }
-            }
-          }
-        }
-      }
-    };
-  }
-  return paths;
-}
-function generateRelationalPaths(resource, relationName, relationConfig, version, relatedSchema) {
-  const resourceName = resource.name;
-  const basePath = `/${version}/${resourceName}/{id}/${relationName}`;
-  relationConfig.resource;
-  const isToMany = relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany";
-  const paths = {};
-  paths[basePath] = {
-    get: {
-      tags: [resourceName],
-      summary: `Get ${relationName} of ${resourceName}`,
-      description: `Retrieve ${relationName} (${relationConfig.type}) associated with this ${resourceName}. This endpoint uses the RelationPlugin to efficiently load related data` + (relationConfig.partitionHint ? ` via the '${relationConfig.partitionHint}' partition.` : "."),
-      parameters: [
-        {
-          name: "id",
-          in: "path",
-          required: true,
-          description: `${resourceName} ID`,
-          schema: { type: "string" }
-        },
-        ...isToMany ? [
-          {
-            name: "limit",
-            in: "query",
-            description: "Maximum number of items to return",
-            schema: { type: "integer", default: 100, minimum: 1, maximum: 1e3 }
-          },
-          {
-            name: "offset",
-            in: "query",
-            description: "Number of items to skip",
-            schema: { type: "integer", default: 0, minimum: 0 }
-          }
-        ] : []
-      ],
-      responses: {
-        200: {
-          description: "Successful response",
-          content: {
-            "application/json": {
-              schema: isToMany ? {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: {
-                    type: "array",
-                    items: relatedSchema
-                  },
-                  pagination: {
-                    type: "object",
-                    properties: {
-                      total: { type: "integer" },
-                      page: { type: "integer" },
-                      pageSize: { type: "integer" },
-                      pageCount: { type: "integer" }
-                    }
-                  }
-                }
-              } : {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: relatedSchema
-                }
-              }
-            }
-          },
-          ...isToMany ? {
-            headers: {
-              "X-Total-Count": {
-                description: "Total number of related records",
-                schema: { type: "integer" }
-              },
-              "X-Page-Count": {
-                description: "Total number of pages",
-                schema: { type: "integer" }
-              }
-            }
-          } : {}
-        },
-        404: {
-          description: `${resourceName} not found` + (isToMany ? "" : " or no related resource exists"),
-          content: {
-            "application/json": {
-              schema: { $ref: "#/components/schemas/Error" }
-            }
-          }
-        }
-      }
-    }
-  };
-  return paths;
-}
-function generateOpenAPISpec(database, config = {}) {
-  const {
-    title = "s3db.js API",
-    version = "1.0.0",
-    description = "Auto-generated REST API documentation for s3db.js resources",
-    serverUrl = "http://localhost:3000",
-    auth = {},
-    resources: resourceConfigs = {}
-  } = config;
-  const resourcesTableRows = [];
-  for (const [name, resource] of Object.entries(database.resources)) {
-    if (name.startsWith("plg_") && !resourceConfigs[name]) {
-      continue;
-    }
-    const version2 = resource.config?.currentVersion || resource.version || "v1";
-    const resourceDescription = resource.config?.description;
-    const descText = typeof resourceDescription === "object" ? resourceDescription.resource : resourceDescription || "No description";
-    resourcesTableRows.push(`| ${name} | ${descText} | \`/${version2}/${name}\` |`);
-  }
-  const enhancedDescription = `${description}
-
-## Available Resources
-
-| Resource | Description | Base Path |
-|----------|-------------|-----------|
-${resourcesTableRows.join("\n")}
-
----
-
-For detailed information about each endpoint, see the sections below.`;
-  const spec = {
-    openapi: "3.1.0",
-    info: {
-      title,
-      version,
-      description: enhancedDescription,
-      contact: {
-        name: "s3db.js",
-        url: "https://github.com/forattini-dev/s3db.js"
-      }
-    },
-    servers: [
-      {
-        url: serverUrl,
-        description: "API Server"
-      }
-    ],
-    paths: {},
-    components: {
-      schemas: {
-        Error: {
-          type: "object",
-          properties: {
-            success: { type: "boolean", example: false },
-            error: {
-              type: "object",
-              properties: {
-                message: { type: "string" },
-                code: { type: "string" },
-                details: { type: "object" }
-              }
-            }
-          }
-        },
-        ValidationError: {
-          type: "object",
-          properties: {
-            success: { type: "boolean", example: false },
-            error: {
-              type: "object",
-              properties: {
-                message: { type: "string", example: "Validation failed" },
-                code: { type: "string", example: "VALIDATION_ERROR" },
-                details: {
-                  type: "object",
-                  properties: {
-                    errors: {
-                      type: "array",
-                      items: {
-                        type: "object",
-                        properties: {
-                          field: { type: "string" },
-                          message: { type: "string" },
-                          expected: { type: "string" },
-                          actual: {}
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      },
-      securitySchemes: {}
-    },
-    tags: []
-  };
-  if (auth.jwt?.enabled) {
-    spec.components.securitySchemes.bearerAuth = {
-      type: "http",
-      scheme: "bearer",
-      bearerFormat: "JWT",
-      description: "JWT authentication"
-    };
-  }
-  if (auth.apiKey?.enabled) {
-    spec.components.securitySchemes.apiKeyAuth = {
-      type: "apiKey",
-      in: "header",
-      name: auth.apiKey.headerName || "X-API-Key",
-      description: "API Key authentication"
-    };
-  }
-  if (auth.basic?.enabled) {
-    spec.components.securitySchemes.basicAuth = {
-      type: "http",
-      scheme: "basic",
-      description: "HTTP Basic authentication"
-    };
-  }
-  const resources = database.resources;
-  const relationsPlugin = database.plugins?.relation || database.plugins?.RelationPlugin || null;
-  for (const [name, resource] of Object.entries(resources)) {
-    if (name.startsWith("plg_") && !resourceConfigs[name]) {
-      continue;
-    }
-    const config2 = resourceConfigs[name] || {
-      methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
-      auth: false
-    };
-    const version2 = resource.config?.currentVersion || resource.version || "v1";
-    const paths = generateResourcePaths(resource, version2, config2);
-    Object.assign(spec.paths, paths);
-    const resourceDescription = resource.config?.description;
-    const tagDescription = typeof resourceDescription === "object" ? resourceDescription.resource : resourceDescription || `Operations for ${name} resource`;
-    spec.tags.push({
-      name,
-      description: tagDescription
-    });
-    spec.components.schemas[name] = generateResourceSchema(resource);
-    if (relationsPlugin && relationsPlugin.relations && relationsPlugin.relations[name]) {
-      const relationsDef = relationsPlugin.relations[name];
-      for (const [relationName, relationConfig] of Object.entries(relationsDef)) {
-        if (relationConfig.type === "belongsTo") {
-          continue;
-        }
-        const exposeRelation = config2?.relations?.[relationName]?.expose !== false;
-        if (!exposeRelation) {
-          continue;
-        }
-        const relatedResource = database.resources[relationConfig.resource];
-        if (!relatedResource) {
-          continue;
-        }
-        const relatedSchema = generateResourceSchema(relatedResource);
-        const relationalPaths = generateRelationalPaths(
-          resource,
-          relationName,
-          relationConfig,
-          version2,
-          relatedSchema
-        );
-        Object.assign(spec.paths, relationalPaths);
-      }
-    }
-  }
-  if (auth.jwt?.enabled || auth.apiKey?.enabled || auth.basic?.enabled) {
-    spec.paths["/auth/login"] = {
-      post: {
-        tags: ["Authentication"],
-        summary: "Login",
-        description: "Authenticate with username and password",
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  username: { type: "string" },
-                  password: { type: "string", format: "password" }
-                },
-                required: ["username", "password"]
-              }
-            }
-          }
-        },
-        responses: {
-          200: {
-            description: "Login successful",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    success: { type: "boolean", example: true },
-                    data: {
-                      type: "object",
-                      properties: {
-                        token: { type: "string" },
-                        user: { type: "object" }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          },
-          401: {
-            description: "Invalid credentials",
-            content: {
-              "application/json": {
-                schema: { $ref: "#/components/schemas/Error" }
-              }
-            }
-          }
-        }
-      }
-    };
-    spec.paths["/auth/register"] = {
-      post: {
-        tags: ["Authentication"],
-        summary: "Register",
-        description: "Register a new user",
-        requestBody: {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  username: { type: "string", minLength: 3 },
-                  password: { type: "string", format: "password", minLength: 8 },
-                  email: { type: "string", format: "email" }
-                },
-                required: ["username", "password"]
-              }
-            }
-          }
-        },
-        responses: {
-          201: {
-            description: "User registered successfully",
-            content: {
-              "application/json": {
-                schema: {
-                  type: "object",
-                  properties: {
-                    success: { type: "boolean", example: true },
-                    data: {
-                      type: "object",
-                      properties: {
-                        token: { type: "string" },
-                        user: { type: "object" }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-    spec.tags.push({
-      name: "Authentication",
-      description: "Authentication endpoints"
-    });
-  }
-  spec.paths["/health"] = {
-    get: {
-      tags: ["Health"],
-      summary: "Generic Health Check",
-      description: "Generic health check endpoint that includes references to liveness and readiness probes",
-      responses: {
-        200: {
-          description: "API is healthy",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: {
-                    type: "object",
-                    properties: {
-                      status: { type: "string", example: "ok" },
-                      uptime: { type: "number", description: "Process uptime in seconds" },
-                      timestamp: { type: "string", format: "date-time" },
-                      checks: {
-                        type: "object",
-                        properties: {
-                          liveness: { type: "string", example: "/health/live" },
-                          readiness: { type: "string", example: "/health/ready" }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  spec.paths["/health/live"] = {
-    get: {
-      tags: ["Health"],
-      summary: "Liveness Probe",
-      description: "Kubernetes liveness probe - checks if the application is alive. If this fails, Kubernetes will restart the pod.",
-      responses: {
-        200: {
-          description: "Application is alive",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: {
-                    type: "object",
-                    properties: {
-                      status: { type: "string", example: "alive" },
-                      timestamp: { type: "string", format: "date-time" }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  spec.paths["/health/ready"] = {
-    get: {
-      tags: ["Health"],
-      summary: "Readiness Probe",
-      description: "Kubernetes readiness probe - checks if the application is ready to receive traffic. If this fails, Kubernetes will remove the pod from service endpoints.",
-      responses: {
-        200: {
-          description: "Application is ready to receive traffic",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: true },
-                  data: {
-                    type: "object",
-                    properties: {
-                      status: { type: "string", example: "ready" },
-                      database: {
-                        type: "object",
-                        properties: {
-                          connected: { type: "boolean", example: true },
-                          resources: { type: "integer", example: 5 }
-                        }
-                      },
-                      timestamp: { type: "string", format: "date-time" }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        },
-        503: {
-          description: "Application is not ready",
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties: {
-                  success: { type: "boolean", example: false },
-                  error: {
-                    type: "object",
-                    properties: {
-                      message: { type: "string", example: "Service not ready" },
-                      code: { type: "string", example: "NOT_READY" },
-                      details: {
-                        type: "object",
-                        properties: {
-                          database: {
-                            type: "object",
-                            properties: {
-                              connected: { type: "boolean", example: false },
-                              resources: { type: "integer", example: 0 }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  spec.tags.push({
-    name: "Health",
-    description: "Health check endpoints for monitoring and Kubernetes probes"
-  });
-  const metricsPlugin = database.plugins?.metrics || database.plugins?.MetricsPlugin;
-  if (metricsPlugin && metricsPlugin.config?.prometheus?.enabled) {
-    const metricsPath = metricsPlugin.config.prometheus.path || "/metrics";
-    const isIntegrated = metricsPlugin.config.prometheus.mode !== "standalone";
-    if (isIntegrated) {
-      spec.paths[metricsPath] = {
-        get: {
-          tags: ["Monitoring"],
-          summary: "Prometheus Metrics",
-          description: "Exposes application metrics in Prometheus text-based exposition format for monitoring and observability. Metrics include operation counts, durations, errors, uptime, and resource statistics.",
-          responses: {
-            200: {
-              description: "Metrics in Prometheus format",
-              content: {
-                "text/plain": {
-                  schema: {
-                    type: "string",
-                    example: '# HELP s3db_operations_total Total number of operations by type and resource\n# TYPE s3db_operations_total counter\ns3db_operations_total{operation="insert",resource="cars"} 1523\ns3db_operations_total{operation="update",resource="cars"} 342\n\n# HELP s3db_operation_duration_seconds Average operation duration in seconds\n# TYPE s3db_operation_duration_seconds gauge\ns3db_operation_duration_seconds{operation="insert",resource="cars"} 0.045\n\n# HELP s3db_operation_errors_total Total number of operation errors\n# TYPE s3db_operation_errors_total counter\ns3db_operation_errors_total{operation="insert",resource="cars"} 12\n'
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-      spec.tags.push({
-        name: "Monitoring",
-        description: "Monitoring and observability endpoints (Prometheus)"
-      });
-    }
-  }
-  return spec;
-}
-
-class ApiServer {
-  /**
-   * Create API server
-   * @param {Object} options - Server options
-   * @param {number} options.port - Server port
-   * @param {string} options.host - Server host
-   * @param {Object} options.database - s3db.js database instance
-   * @param {Object} options.resources - Resource configuration
-   * @param {Array} options.middlewares - Global middlewares
-   */
-  constructor(options = {}) {
-    this.options = {
-      port: options.port || 3e3,
-      host: options.host || "0.0.0.0",
-      database: options.database,
-      resources: options.resources || {},
-      middlewares: options.middlewares || [],
-      verbose: options.verbose || false,
-      auth: options.auth || {},
-      docsEnabled: options.docsEnabled !== false,
-      // Enable /docs by default
-      docsUI: options.docsUI || "redoc",
-      // 'swagger' or 'redoc'
-      maxBodySize: options.maxBodySize || 10 * 1024 * 1024,
-      // 10MB default
-      rootHandler: options.rootHandler,
-      // Custom handler for root path, if not provided redirects to /docs
-      apiInfo: {
-        title: options.apiTitle || "s3db.js API",
-        version: options.apiVersion || "1.0.0",
-        description: options.apiDescription || "Auto-generated REST API for s3db.js resources"
-      }
-    };
-    this.app = new Hono();
-    this.server = null;
-    this.isRunning = false;
-    this.openAPISpec = null;
-    this.relationsPlugin = this.options.database?.plugins?.relation || this.options.database?.plugins?.RelationPlugin || null;
-    this._setupRoutes();
-  }
-  /**
-   * Setup all routes
-   * @private
-   */
-  _setupRoutes() {
-    this.options.middlewares.forEach((middleware) => {
-      this.app.use("*", middleware);
-    });
-    this.app.use("*", async (c, next) => {
-      const method = c.req.method;
-      if (["POST", "PUT", "PATCH"].includes(method)) {
-        const contentLength = c.req.header("content-length");
-        if (contentLength) {
-          const size = parseInt(contentLength);
-          if (size > this.options.maxBodySize) {
-            const response = payloadTooLarge(size, this.options.maxBodySize);
-            c.header("Connection", "close");
-            return c.json(response, response._status);
-          }
-        }
-      }
-      await next();
-    });
-    this.app.get("/health/live", (c) => {
-      const response = success({
-        status: "alive",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return c.json(response);
-    });
-    this.app.get("/health/ready", (c) => {
-      const isReady = this.options.database && this.options.database.connected && Object.keys(this.options.database.resources).length > 0;
-      if (!isReady) {
-        const response2 = error("Service not ready", {
-          status: 503,
-          code: "NOT_READY",
-          details: {
-            database: {
-              connected: this.options.database?.connected || false,
-              resources: Object.keys(this.options.database?.resources || {}).length
-            }
-          }
-        });
-        return c.json(response2, 503);
-      }
-      const response = success({
-        status: "ready",
-        database: {
-          connected: true,
-          resources: Object.keys(this.options.database.resources).length
-        },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      return c.json(response);
-    });
-    this.app.get("/health", (c) => {
-      const response = success({
-        status: "ok",
-        uptime: process.uptime(),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        checks: {
-          liveness: "/health/live",
-          readiness: "/health/ready"
-        }
-      });
-      return c.json(response);
-    });
-    this.app.get("/", (c) => {
-      if (this.options.rootHandler) {
-        return this.options.rootHandler(c);
-      }
-      return c.redirect("/docs", 302);
-    });
-    if (this.options.docsEnabled) {
-      this.app.get("/openapi.json", (c) => {
-        if (!this.openAPISpec) {
-          this.openAPISpec = this._generateOpenAPISpec();
-        }
-        return c.json(this.openAPISpec);
-      });
-      if (this.options.docsUI === "swagger") {
-        this.app.get("/docs", swaggerUI({
-          url: "/openapi.json"
-        }));
-      } else {
-        this.app.get("/docs", (c) => {
-          return c.html(`<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${this.options.apiInfo.title} - API Documentation</title>
-  <style>
-    body {
-      margin: 0;
-      padding: 0;
-    }
-  </style>
-</head>
-<body>
-  <redoc spec-url="/openapi.json"></redoc>
-  <script src="https://cdn.redoc.ly/redoc/v2.5.1/bundles/redoc.standalone.js"><\/script>
-</body>
-</html>`);
-        });
-      }
-    }
-    this._setupResourceRoutes();
-    if (this.relationsPlugin) {
-      this._setupRelationalRoutes();
-    }
-    this.app.onError((err, c) => {
-      return errorHandler(err, c);
-    });
-    this.app.notFound((c) => {
-      const response = error("Route not found", {
-        status: 404,
-        code: "NOT_FOUND",
-        details: {
-          path: c.req.path,
-          method: c.req.method
-        }
-      });
-      return c.json(response, 404);
-    });
-  }
-  /**
-   * Setup routes for all resources
-   * @private
-   */
-  _setupResourceRoutes() {
-    const { database, resources: resourceConfigs } = this.options;
-    const resources = database.resources;
-    for (const [name, resource] of Object.entries(resources)) {
-      if (name.startsWith("plg_") && !resourceConfigs[name]) {
-        continue;
-      }
-      const config = resourceConfigs[name] || {
-        methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]};
-      const version = resource.config?.currentVersion || resource.version || "v1";
-      const resourceApp = createResourceRoutes(resource, version, {
-        methods: config.methods,
-        customMiddleware: config.customMiddleware || [],
-        enableValidation: config.validation !== false
-      });
-      this.app.route(`/${version}/${name}`, resourceApp);
-      if (this.options.verbose) {
-        console.log(`[API Plugin] Mounted routes for resource '${name}' at /${version}/${name}`);
-      }
-    }
-  }
-  /**
-   * Setup relational routes (when RelationPlugin is active)
-   * @private
-   */
-  _setupRelationalRoutes() {
-    if (!this.relationsPlugin || !this.relationsPlugin.relations) {
-      return;
-    }
-    const { database } = this.options;
-    const relations = this.relationsPlugin.relations;
-    if (this.options.verbose) {
-      console.log("[API Plugin] Setting up relational routes...");
-    }
-    for (const [resourceName, relationsDef] of Object.entries(relations)) {
-      const resource = database.resources[resourceName];
-      if (!resource) {
-        if (this.options.verbose) {
-          console.warn(`[API Plugin] Resource '${resourceName}' not found for relational routes`);
-        }
-        continue;
-      }
-      if (resourceName.startsWith("plg_") && !this.options.resources[resourceName]) {
-        continue;
-      }
-      const version = resource.config?.currentVersion || resource.version || "v1";
-      for (const [relationName, relationConfig] of Object.entries(relationsDef)) {
-        if (relationConfig.type === "belongsTo") {
-          continue;
-        }
-        const resourceConfig = this.options.resources[resourceName];
-        const exposeRelation = resourceConfig?.relations?.[relationName]?.expose !== false;
-        if (!exposeRelation) {
-          continue;
-        }
-        const relationalApp = createRelationalRoutes(
-          resource,
-          relationName,
-          relationConfig);
-        this.app.route(`/${version}/${resourceName}/:id/${relationName}`, relationalApp);
-        if (this.options.verbose) {
-          console.log(
-            `[API Plugin] Mounted relational route: /${version}/${resourceName}/:id/${relationName} (${relationConfig.type} -> ${relationConfig.resource})`
-          );
-        }
-      }
-    }
-  }
-  /**
-   * Start the server
-   * @returns {Promise<void>}
-   */
-  async start() {
-    if (this.isRunning) {
-      console.warn("[API Plugin] Server is already running");
-      return;
-    }
-    const { port, host } = this.options;
-    return new Promise((resolve, reject) => {
-      try {
-        this.server = serve({
-          fetch: this.app.fetch,
-          port,
-          hostname: host
-        }, (info) => {
-          this.isRunning = true;
-          console.log(`[API Plugin] Server listening on http://${info.address}:${info.port}`);
-          resolve();
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-  /**
-   * Stop the server
-   * @returns {Promise<void>}
-   */
-  async stop() {
-    if (!this.isRunning) {
-      console.warn("[API Plugin] Server is not running");
-      return;
-    }
-    if (this.server && typeof this.server.close === "function") {
-      await new Promise((resolve) => {
-        this.server.close(() => {
-          this.isRunning = false;
-          console.log("[API Plugin] Server stopped");
-          resolve();
-        });
-      });
-    } else {
-      this.isRunning = false;
-      console.log("[API Plugin] Server stopped");
-    }
-  }
-  /**
-   * Get server info
-   * @returns {Object} Server information
-   */
-  getInfo() {
-    return {
-      isRunning: this.isRunning,
-      port: this.options.port,
-      host: this.options.host,
-      resources: Object.keys(this.options.database.resources).length
-    };
-  }
-  /**
-   * Get Hono app instance
-   * @returns {Hono} Hono app
-   */
-  getApp() {
-    return this.app;
-  }
-  /**
-   * Generate OpenAPI specification
-   * @private
-   * @returns {Object} OpenAPI spec
-   */
-  _generateOpenAPISpec() {
-    const { port, host, database, resources, auth, apiInfo } = this.options;
-    return generateOpenAPISpec(database, {
-      title: apiInfo.title,
-      version: apiInfo.version,
-      description: apiInfo.description,
-      serverUrl: `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`,
-      auth,
-      resources
-    });
-  }
-}
-
 const PLUGIN_DEPENDENCIES = {
   "postgresql-replicator": {
     name: "PostgreSQL Replicator",
@@ -4973,6 +3008,11 @@ class ApiPlugin extends Plugin {
     if (this.config.verbose) {
       console.log("[API Plugin] Starting server...");
     }
+    const serverPath = "./server.js";
+    const { ApiServer } = await import(
+      /* @vite-ignore */
+      serverPath
+    );
     this.server = new ApiServer({
       port: this.config.port,
       host: this.config.host,
@@ -12582,6 +10622,605 @@ class FullTextPlugin extends Plugin {
   }
 }
 
+class GeoPlugin extends Plugin {
+  constructor(config = {}) {
+    super(config);
+    this.resources = config.resources || {};
+    this.verbose = config.verbose !== void 0 ? config.verbose : false;
+    this.base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
+  }
+  /**
+   * Install the plugin
+   */
+  async install(database) {
+    await super.install(database);
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      await this._setupResource(resourceName, config);
+    }
+    this.database.addHook("afterCreateResource", async (context) => {
+      const { resource, config: resourceConfig } = context;
+      const geoConfig = this.resources[resource.name];
+      if (geoConfig) {
+        await this._setupResource(resource.name, geoConfig);
+      }
+    });
+    if (this.verbose) {
+      console.log(`[GeoPlugin] Installed with ${Object.keys(this.resources).length} resources`);
+    }
+    this.emit("installed", {
+      plugin: "GeoPlugin",
+      resources: Object.keys(this.resources)
+    });
+  }
+  /**
+   * Setup a resource with geo capabilities
+   */
+  async _setupResource(resourceName, config) {
+    if (!this.database.resources[resourceName]) {
+      if (this.verbose) {
+        console.warn(`[GeoPlugin] Resource "${resourceName}" not found, will setup when created`);
+      }
+      return;
+    }
+    const resource = this.database.resources[resourceName];
+    if (!resource || typeof resource.addHook !== "function") {
+      if (this.verbose) {
+        console.warn(`[GeoPlugin] Resource "${resourceName}" not found or invalid`);
+      }
+      return;
+    }
+    if (!config.latField || !config.lonField) {
+      throw new Error(
+        `[GeoPlugin] Resource "${resourceName}" must have "latField" and "lonField" configured`
+      );
+    }
+    if (!config.precision || config.precision < 1 || config.precision > 12) {
+      config.precision = 5;
+    }
+    resource._geoConfig = config;
+    const latField = resource.attributes[config.latField];
+    const lonField = resource.attributes[config.lonField];
+    const isLatOptional = typeof latField === "object" && latField.optional === true;
+    const isLonOptional = typeof lonField === "object" && lonField.optional === true;
+    const areCoordinatesOptional = isLatOptional || isLonOptional;
+    const geohashType = areCoordinatesOptional ? "string|optional" : "string";
+    let needsUpdate = false;
+    const newAttributes = { ...resource.attributes };
+    if (config.addGeohash && !newAttributes.geohash) {
+      newAttributes.geohash = geohashType;
+      needsUpdate = true;
+    }
+    if (!newAttributes._geohash) {
+      newAttributes._geohash = geohashType;
+      needsUpdate = true;
+    }
+    if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+      for (const zoom of config.zoomLevels) {
+        const fieldName = `_geohash_zoom${zoom}`;
+        if (!newAttributes[fieldName]) {
+          newAttributes[fieldName] = geohashType;
+          needsUpdate = true;
+        }
+      }
+    }
+    if (needsUpdate) {
+      resource.updateAttributes(newAttributes);
+      if (this.database.uploadMetadataFile) {
+        await this.database.uploadMetadataFile();
+      }
+    }
+    if (config.usePartitions) {
+      await this._setupPartitions(resource, config);
+    }
+    this._addHooks(resource, config);
+    this._addHelperMethods(resource, config);
+    if (this.verbose) {
+      console.log(
+        `[GeoPlugin] Setup resource "${resourceName}" with precision ${config.precision} (~${this._getPrecisionDistance(config.precision)}km cells)` + (config.usePartitions ? " [Partitions enabled]" : "")
+      );
+    }
+  }
+  /**
+   * Setup geohash partitions for efficient spatial queries
+   * Creates multiple zoom-level partitions if zoomLevels configured
+   */
+  async _setupPartitions(resource, config) {
+    const updatedConfig = { ...resource.config };
+    updatedConfig.partitions = updatedConfig.partitions || {};
+    let partitionsCreated = 0;
+    if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+      for (const zoom of config.zoomLevels) {
+        const partitionName = `byGeohashZoom${zoom}`;
+        const fieldName = `_geohash_zoom${zoom}`;
+        if (!updatedConfig.partitions[partitionName]) {
+          updatedConfig.partitions[partitionName] = {
+            fields: {
+              [fieldName]: "string"
+            }
+          };
+          partitionsCreated++;
+          if (this.verbose) {
+            console.log(
+              `[GeoPlugin] Created ${partitionName} partition for "${resource.name}" (precision ${zoom}, ~${this._getPrecisionDistance(zoom)}km cells)`
+            );
+          }
+        }
+      }
+    } else {
+      const hasGeohashPartition = resource.config.partitions && resource.config.partitions.byGeohash;
+      if (!hasGeohashPartition) {
+        updatedConfig.partitions.byGeohash = {
+          fields: {
+            _geohash: "string"
+          }
+        };
+        partitionsCreated++;
+        if (this.verbose) {
+          console.log(`[GeoPlugin] Created byGeohash partition for "${resource.name}"`);
+        }
+      }
+    }
+    if (partitionsCreated > 0) {
+      resource.config = updatedConfig;
+      resource.setupPartitionHooks();
+      if (this.database.uploadMetadataFile) {
+        await this.database.uploadMetadataFile();
+      }
+    }
+  }
+  /**
+   * Add hooks to automatically calculate geohash at all zoom levels
+   */
+  _addHooks(resource, config) {
+    const calculateGeohash = async (data) => {
+      const lat = data[config.latField];
+      const lon = data[config.lonField];
+      if (lat !== void 0 && lon !== void 0) {
+        const geohash = this.encodeGeohash(lat, lon, config.precision);
+        if (config.addGeohash) {
+          data.geohash = geohash;
+        }
+        data._geohash = geohash;
+        if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+          for (const zoom of config.zoomLevels) {
+            const zoomGeohash = this.encodeGeohash(lat, lon, zoom);
+            data[`_geohash_zoom${zoom}`] = zoomGeohash;
+          }
+        }
+      }
+      return data;
+    };
+    resource.addHook("beforeInsert", calculateGeohash);
+    resource.addHook("beforeUpdate", calculateGeohash);
+  }
+  /**
+   * Add helper methods to resource
+   */
+  _addHelperMethods(resource, config) {
+    const plugin = this;
+    resource.findNearby = async function({ lat, lon, radius = 10, limit = 100 }) {
+      if (lat === void 0 || lon === void 0) {
+        throw new Error("lat and lon are required for findNearby");
+      }
+      const longitude = lon;
+      let allRecords = [];
+      if (config.usePartitions) {
+        let partitionName, fieldName, precision;
+        if (config.zoomLevels && config.zoomLevels.length > 0) {
+          const optimalZoom = plugin._selectOptimalZoom(config.zoomLevels, radius);
+          partitionName = `byGeohashZoom${optimalZoom}`;
+          fieldName = `_geohash_zoom${optimalZoom}`;
+          precision = optimalZoom;
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] Auto-selected zoom${optimalZoom} (${plugin._getPrecisionDistance(optimalZoom)}km cells) for ${radius}km radius query`
+            );
+          }
+        } else {
+          partitionName = "byGeohash";
+          fieldName = "_geohash";
+          precision = config.precision;
+        }
+        if (this.config.partitions?.[partitionName]) {
+          const centerGeohash = plugin.encodeGeohash(lat, longitude, precision);
+          const neighbors = plugin.getNeighbors(centerGeohash);
+          const geohashesToSearch = [centerGeohash, ...neighbors];
+          const partitionResults = await Promise.all(
+            geohashesToSearch.map(async (geohash) => {
+              const [ok, err, records] = await tryFn(async () => {
+                return await this.listPartition({
+                  partition: partitionName,
+                  partitionValues: { [fieldName]: geohash },
+                  limit: limit * 2
+                });
+              });
+              return ok ? records : [];
+            })
+          );
+          allRecords = partitionResults.flat();
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] findNearby searched ${geohashesToSearch.length} ${partitionName} partitions, found ${allRecords.length} candidates`
+            );
+          }
+        } else {
+          allRecords = await this.list({ limit: limit * 10 });
+        }
+      } else {
+        allRecords = await this.list({ limit: limit * 10 });
+      }
+      const withDistances = allRecords.map((record) => {
+        const recordLat = record[config.latField];
+        const recordLon = record[config.lonField];
+        if (recordLat === void 0 || recordLon === void 0) {
+          return null;
+        }
+        const distance = plugin.calculateDistance(lat, longitude, recordLat, recordLon);
+        return {
+          ...record,
+          _distance: distance
+        };
+      }).filter((record) => record !== null && record._distance <= radius).sort((a, b) => a._distance - b._distance).slice(0, limit);
+      return withDistances;
+    };
+    resource.findInBounds = async function({ north, south, east, west, limit = 100 }) {
+      if (north === void 0 || south === void 0 || east === void 0 || west === void 0) {
+        throw new Error("north, south, east, west are required for findInBounds");
+      }
+      let allRecords = [];
+      if (config.usePartitions) {
+        let partitionName, precision;
+        if (config.zoomLevels && config.zoomLevels.length > 0) {
+          const centerLat = (north + south) / 2;
+          const centerLon = (east + west) / 2;
+          const latRadius = plugin.calculateDistance(centerLat, centerLon, north, centerLon);
+          const lonRadius = plugin.calculateDistance(centerLat, centerLon, centerLat, east);
+          const approximateRadius = Math.max(latRadius, lonRadius);
+          const optimalZoom = plugin._selectOptimalZoom(config.zoomLevels, approximateRadius);
+          partitionName = `byGeohashZoom${optimalZoom}`;
+          precision = optimalZoom;
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] Auto-selected zoom${optimalZoom} (${plugin._getPrecisionDistance(optimalZoom)}km cells) for ${approximateRadius.toFixed(1)}km bounding box`
+            );
+          }
+        } else {
+          partitionName = "byGeohash";
+          precision = config.precision;
+        }
+        if (this.config.partitions?.[partitionName]) {
+          const geohashesToSearch = plugin._getGeohashesInBounds({
+            north,
+            south,
+            east,
+            west,
+            precision
+          });
+          const partitionResults = await Promise.all(
+            geohashesToSearch.map(async (geohash) => {
+              const [ok, err, records] = await tryFn(async () => {
+                const fieldName = config.zoomLevels ? `_geohash_zoom${precision}` : "_geohash";
+                return await this.listPartition({
+                  partition: partitionName,
+                  partitionValues: { [fieldName]: geohash },
+                  limit: limit * 2
+                });
+              });
+              return ok ? records : [];
+            })
+          );
+          allRecords = partitionResults.flat();
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] findInBounds searched ${geohashesToSearch.length} ${partitionName} partitions, found ${allRecords.length} candidates`
+            );
+          }
+        } else {
+          allRecords = await this.list({ limit: limit * 10 });
+        }
+      } else {
+        allRecords = await this.list({ limit: limit * 10 });
+      }
+      const inBounds = allRecords.filter((record) => {
+        const lat = record[config.latField];
+        const lon = record[config.lonField];
+        if (lat === void 0 || lon === void 0) {
+          return false;
+        }
+        return lat <= north && lat >= south && lon <= east && lon >= west;
+      }).slice(0, limit);
+      return inBounds;
+    };
+    resource.getDistance = async function(id1, id2) {
+      let record1, record2;
+      try {
+        [record1, record2] = await Promise.all([
+          this.get(id1),
+          this.get(id2)
+        ]);
+      } catch (err) {
+        if (err.name === "NoSuchKey" || err.message?.includes("No such key")) {
+          throw new Error("One or both records not found");
+        }
+        throw err;
+      }
+      if (!record1 || !record2) {
+        throw new Error("One or both records not found");
+      }
+      const lat1 = record1[config.latField];
+      const lon1 = record1[config.lonField];
+      const lat2 = record2[config.latField];
+      const lon2 = record2[config.lonField];
+      if (lat1 === void 0 || lon1 === void 0 || lat2 === void 0 || lon2 === void 0) {
+        throw new Error("One or both records missing coordinates");
+      }
+      const distance = plugin.calculateDistance(lat1, lon1, lat2, lon2);
+      return {
+        distance,
+        unit: "km",
+        from: id1,
+        to: id2
+      };
+    };
+  }
+  /**
+   * Encode coordinates to geohash
+   * @param {number} latitude - Latitude (-90 to 90)
+   * @param {number} longitude - Longitude (-180 to 180)
+   * @param {number} precision - Number of characters in geohash
+   * @returns {string} Geohash string
+   */
+  encodeGeohash(latitude, longitude, precision = 5) {
+    let idx = 0;
+    let bit = 0;
+    let evenBit = true;
+    let geohash = "";
+    let latMin = -90;
+    let latMax = 90;
+    let lonMin = -180;
+    let lonMax = 180;
+    while (geohash.length < precision) {
+      if (evenBit) {
+        const lonMid = (lonMin + lonMax) / 2;
+        if (longitude > lonMid) {
+          idx |= 1 << 4 - bit;
+          lonMin = lonMid;
+        } else {
+          lonMax = lonMid;
+        }
+      } else {
+        const latMid = (latMin + latMax) / 2;
+        if (latitude > latMid) {
+          idx |= 1 << 4 - bit;
+          latMin = latMid;
+        } else {
+          latMax = latMid;
+        }
+      }
+      evenBit = !evenBit;
+      if (bit < 4) {
+        bit++;
+      } else {
+        geohash += this.base32[idx];
+        bit = 0;
+        idx = 0;
+      }
+    }
+    return geohash;
+  }
+  /**
+   * Decode geohash to coordinates
+   * @param {string} geohash - Geohash string
+   * @returns {Object} { latitude, longitude, error }
+   */
+  decodeGeohash(geohash) {
+    let evenBit = true;
+    let latMin = -90;
+    let latMax = 90;
+    let lonMin = -180;
+    let lonMax = 180;
+    for (let i = 0; i < geohash.length; i++) {
+      const chr = geohash[i];
+      const idx = this.base32.indexOf(chr);
+      if (idx === -1) {
+        throw new Error(`Invalid geohash character: ${chr}`);
+      }
+      for (let n = 4; n >= 0; n--) {
+        const bitN = idx >> n & 1;
+        if (evenBit) {
+          const lonMid = (lonMin + lonMax) / 2;
+          if (bitN === 1) {
+            lonMin = lonMid;
+          } else {
+            lonMax = lonMid;
+          }
+        } else {
+          const latMid = (latMin + latMax) / 2;
+          if (bitN === 1) {
+            latMin = latMid;
+          } else {
+            latMax = latMid;
+          }
+        }
+        evenBit = !evenBit;
+      }
+    }
+    const latitude = (latMin + latMax) / 2;
+    const longitude = (lonMin + lonMax) / 2;
+    return {
+      latitude,
+      longitude,
+      error: {
+        latitude: latMax - latMin,
+        longitude: lonMax - lonMin
+      }
+    };
+  }
+  /**
+   * Calculate distance between two coordinates using Haversine formula
+   * @param {number} lat1 - Latitude of point 1
+   * @param {number} lon1 - Longitude of point 1
+   * @param {number} lat2 - Latitude of point 2
+   * @param {number} lon2 - Longitude of point 2
+   * @returns {number} Distance in kilometers
+   */
+  calculateDistance(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = this._toRadians(lat2 - lat1);
+    const dLon = this._toRadians(lon2 - lon1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(this._toRadians(lat1)) * Math.cos(this._toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return R * c;
+  }
+  /**
+   * Get geohash neighbors (8 surrounding cells)
+   * @param {string} geohash - Center geohash
+   * @returns {Array<string>} Array of 8 neighboring geohashes
+   */
+  getNeighbors(geohash) {
+    const decoded = this.decodeGeohash(geohash);
+    const { latitude, longitude, error } = decoded;
+    const latStep = error.latitude;
+    const lonStep = error.longitude;
+    const neighbors = [];
+    const directions = [
+      [-latStep, -lonStep],
+      // SW
+      [-latStep, 0],
+      // S
+      [-latStep, lonStep],
+      // SE
+      [0, -lonStep],
+      // W
+      [0, lonStep],
+      // E
+      [latStep, -lonStep],
+      // NW
+      [latStep, 0],
+      // N
+      [latStep, lonStep]
+      // NE
+    ];
+    for (const [latDelta, lonDelta] of directions) {
+      const neighborHash = this.encodeGeohash(
+        latitude + latDelta,
+        longitude + lonDelta,
+        geohash.length
+      );
+      neighbors.push(neighborHash);
+    }
+    return neighbors;
+  }
+  /**
+   * Get all geohashes that cover a bounding box
+   * @param {Object} bounds - Bounding box { north, south, east, west, precision }
+   * @returns {Array<string>} Array of unique geohashes covering the area
+   */
+  _getGeohashesInBounds({ north, south, east, west, precision }) {
+    const geohashes = /* @__PURE__ */ new Set();
+    const cellSize = this._getPrecisionDistance(precision);
+    const latStep = cellSize / 111;
+    const lonStep = cellSize / (111 * Math.cos(this._toRadians((north + south) / 2)));
+    for (let lat = south; lat <= north; lat += latStep) {
+      for (let lon = west; lon <= east; lon += lonStep) {
+        const geohash = this.encodeGeohash(lat, lon, precision);
+        geohashes.add(geohash);
+      }
+    }
+    const corners = [
+      [north, west],
+      [north, east],
+      [south, west],
+      [south, east],
+      [(north + south) / 2, west],
+      [(north + south) / 2, east],
+      [north, (east + west) / 2],
+      [south, (east + west) / 2]
+    ];
+    for (const [lat, lon] of corners) {
+      const geohash = this.encodeGeohash(lat, lon, precision);
+      geohashes.add(geohash);
+    }
+    return Array.from(geohashes);
+  }
+  /**
+   * Convert degrees to radians
+   */
+  _toRadians(degrees) {
+    return degrees * (Math.PI / 180);
+  }
+  /**
+   * Get approximate cell size for precision level
+   */
+  _getPrecisionDistance(precision) {
+    const distances = {
+      1: 5e3,
+      2: 1250,
+      3: 156,
+      4: 39,
+      5: 4.9,
+      6: 1.2,
+      7: 0.15,
+      8: 0.038,
+      9: 47e-4,
+      10: 12e-4,
+      11: 15e-5,
+      12: 37e-6
+    };
+    return distances[precision] || 5;
+  }
+  /**
+   * Select optimal zoom level based on search radius
+   * @param {Array<number>} zoomLevels - Available zoom levels
+   * @param {number} radiusKm - Search radius in kilometers
+   * @returns {number} Optimal zoom precision
+   */
+  _selectOptimalZoom(zoomLevels, radiusKm) {
+    if (!zoomLevels || zoomLevels.length === 0) {
+      return null;
+    }
+    const targetCellSize = radiusKm / 2.5;
+    let bestZoom = zoomLevels[0];
+    let bestDiff = Math.abs(this._getPrecisionDistance(bestZoom) - targetCellSize);
+    for (const zoom of zoomLevels) {
+      const cellSize = this._getPrecisionDistance(zoom);
+      const diff = Math.abs(cellSize - targetCellSize);
+      if (diff < bestDiff) {
+        bestDiff = diff;
+        bestZoom = zoom;
+      }
+    }
+    return bestZoom;
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    return {
+      resources: Object.keys(this.resources).length,
+      configurations: Object.entries(this.resources).map(([name, config]) => ({
+        resource: name,
+        latField: config.latField,
+        lonField: config.lonField,
+        precision: config.precision,
+        cellSize: `~${this._getPrecisionDistance(config.precision)}km`
+      }))
+    };
+  }
+  /**
+   * Uninstall the plugin
+   */
+  async uninstall() {
+    if (this.verbose) {
+      console.log("[GeoPlugin] Uninstalled");
+    }
+    this.emit("uninstalled", {
+      plugin: "GeoPlugin"
+    });
+    await super.uninstall();
+  }
+}
+
 class MetricsPlugin extends Plugin {
   constructor(options = {}) {
     super();
@@ -22391,7 +21030,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.2.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.2.2" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -37306,6 +35945,532 @@ class TfStatePlugin extends Plugin {
   }
 }
 
+const GRANULARITIES = {
+  minute: {
+    threshold: 3600,
+    // TTL < 1 hour
+    interval: 1e4,
+    // Check every 10 seconds
+    cohortsToCheck: 3,
+    // Check last 3 minutes
+    cohortFormat: (date) => date.toISOString().substring(0, 16)
+    // '2024-10-25T14:30'
+  },
+  hour: {
+    threshold: 86400,
+    // TTL < 24 hours
+    interval: 6e5,
+    // Check every 10 minutes
+    cohortsToCheck: 2,
+    // Check last 2 hours
+    cohortFormat: (date) => date.toISOString().substring(0, 13)
+    // '2024-10-25T14'
+  },
+  day: {
+    threshold: 2592e3,
+    // TTL < 30 days
+    interval: 36e5,
+    // Check every 1 hour
+    cohortsToCheck: 2,
+    // Check last 2 days
+    cohortFormat: (date) => date.toISOString().substring(0, 10)
+    // '2024-10-25'
+  },
+  week: {
+    threshold: Infinity,
+    // TTL >= 30 days
+    interval: 864e5,
+    // Check every 24 hours
+    cohortsToCheck: 2,
+    // Check last 2 weeks
+    cohortFormat: (date) => {
+      const year = date.getUTCFullYear();
+      const week = getWeekNumber(date);
+      return `${year}-W${String(week).padStart(2, "0")}`;
+    }
+  }
+};
+function getWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d - yearStart) / 864e5 + 1) / 7);
+}
+function detectGranularity(ttl) {
+  if (!ttl) return "day";
+  if (ttl < GRANULARITIES.minute.threshold) return "minute";
+  if (ttl < GRANULARITIES.hour.threshold) return "hour";
+  if (ttl < GRANULARITIES.day.threshold) return "day";
+  return "week";
+}
+function getExpiredCohorts(granularity, count) {
+  const config = GRANULARITIES[granularity];
+  const cohorts = [];
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 0; i < count; i++) {
+    let checkDate;
+    switch (granularity) {
+      case "minute":
+        checkDate = new Date(now.getTime() - i * 6e4);
+        break;
+      case "hour":
+        checkDate = new Date(now.getTime() - i * 36e5);
+        break;
+      case "day":
+        checkDate = new Date(now.getTime() - i * 864e5);
+        break;
+      case "week":
+        checkDate = new Date(now.getTime() - i * 6048e5);
+        break;
+    }
+    cohorts.push(config.cohortFormat(checkDate));
+  }
+  return cohorts;
+}
+class TTLPlugin extends Plugin {
+  constructor(config = {}) {
+    super(config);
+    this.verbose = config.verbose !== void 0 ? config.verbose : false;
+    this.resources = config.resources || {};
+    this.batchSize = config.batchSize || 100;
+    this.stats = {
+      totalScans: 0,
+      totalExpired: 0,
+      totalDeleted: 0,
+      totalArchived: 0,
+      totalSoftDeleted: 0,
+      totalCallbacks: 0,
+      totalErrors: 0,
+      lastScanAt: null,
+      lastScanDuration: 0
+    };
+    this.intervals = [];
+    this.isRunning = false;
+    this.expirationIndex = null;
+  }
+  /**
+   * Install the plugin
+   */
+  async install(database) {
+    await super.install(database);
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      this._validateResourceConfig(resourceName, config);
+    }
+    await this._createExpirationIndex();
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      this._setupResourceHooks(resourceName, config);
+    }
+    this._startIntervals();
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Installed with ${Object.keys(this.resources).length} resources`);
+    }
+    this.emit("installed", {
+      plugin: "TTLPlugin",
+      resources: Object.keys(this.resources)
+    });
+  }
+  /**
+   * Validate resource configuration
+   */
+  _validateResourceConfig(resourceName, config) {
+    if (!config.ttl && !config.field) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" must have either "ttl" (seconds) or "field" (timestamp field name)`
+      );
+    }
+    const validStrategies = ["soft-delete", "hard-delete", "archive", "callback"];
+    if (!config.onExpire || !validStrategies.includes(config.onExpire)) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" must have an "onExpire" value. Valid options: ${validStrategies.join(", ")}`
+      );
+    }
+    if (config.onExpire === "soft-delete" && !config.deleteField) {
+      config.deleteField = "deletedat";
+    }
+    if (config.onExpire === "archive" && !config.archiveResource) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" with onExpire="archive" must have an "archiveResource" specified`
+      );
+    }
+    if (config.onExpire === "callback" && typeof config.callback !== "function") {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" with onExpire="callback" must have a "callback" function`
+      );
+    }
+    if (!config.field) {
+      config.field = "_createdAt";
+    }
+    if (config.field === "_createdAt" && this.database) {
+      const resource = this.database.resources[resourceName];
+      if (resource && resource.config && resource.config.timestamps === false) {
+        console.warn(
+          `[TTLPlugin] WARNING: Resource "${resourceName}" uses TTL with field "_createdAt" but timestamps are disabled. TTL will be calculated from indexing time, not creation time.`
+        );
+      }
+    }
+    config.granularity = detectGranularity(config.ttl);
+  }
+  /**
+   * Create expiration index (plugin resource)
+   */
+  async _createExpirationIndex() {
+    this.expirationIndex = await this.database.createResource({
+      name: "plg_ttl_expiration_index",
+      attributes: {
+        resourceName: "string|required",
+        recordId: "string|required",
+        expiresAtCohort: "string|required",
+        expiresAtTimestamp: "number|required",
+        // Exact expiration timestamp for precise checking
+        granularity: "string|required",
+        createdAt: "number"
+      },
+      partitions: {
+        byExpiresAtCohort: {
+          fields: { expiresAtCohort: "string" }
+        }
+      },
+      asyncPartitions: false
+      // Sync partitions for deterministic behavior
+    });
+    if (this.verbose) {
+      console.log("[TTLPlugin] Created expiration index with partition");
+    }
+  }
+  /**
+   * Setup hooks for a resource
+   */
+  _setupResourceHooks(resourceName, config) {
+    if (!this.database.resources[resourceName]) {
+      if (this.verbose) {
+        console.warn(`[TTLPlugin] Resource "${resourceName}" not found, skipping hooks`);
+      }
+      return;
+    }
+    const resource = this.database.resources[resourceName];
+    if (typeof resource.insert !== "function" || typeof resource.delete !== "function") {
+      if (this.verbose) {
+        console.warn(`[TTLPlugin] Resource "${resourceName}" missing insert/delete methods, skipping hooks`);
+      }
+      return;
+    }
+    this.addMiddleware(resource, "insert", async (next, data, options) => {
+      const result = await next(data, options);
+      await this._addToIndex(resourceName, result, config);
+      return result;
+    });
+    this.addMiddleware(resource, "delete", async (next, id, options) => {
+      const result = await next(id, options);
+      await this._removeFromIndex(resourceName, id);
+      return result;
+    });
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Setup hooks for resource "${resourceName}"`);
+    }
+  }
+  /**
+   * Add record to expiration index
+   */
+  async _addToIndex(resourceName, record, config) {
+    try {
+      let baseTime = record[config.field];
+      if (!baseTime && config.field === "_createdAt") {
+        baseTime = Date.now();
+      }
+      if (!baseTime) {
+        if (this.verbose) {
+          console.warn(
+            `[TTLPlugin] Record ${record.id} in ${resourceName} missing field "${config.field}", skipping index`
+          );
+        }
+        return;
+      }
+      const baseTimestamp = typeof baseTime === "number" ? baseTime : new Date(baseTime).getTime();
+      const expiresAt = config.ttl ? new Date(baseTimestamp + config.ttl * 1e3) : new Date(baseTimestamp);
+      const cohortConfig = GRANULARITIES[config.granularity];
+      const cohort = cohortConfig.cohortFormat(expiresAt);
+      const indexId = `${resourceName}:${record.id}`;
+      await this.expirationIndex.insert({
+        id: indexId,
+        resourceName,
+        recordId: record.id,
+        expiresAtCohort: cohort,
+        expiresAtTimestamp: expiresAt.getTime(),
+        // Store exact timestamp for precise checking
+        granularity: config.granularity,
+        createdAt: Date.now()
+      });
+      if (this.verbose) {
+        console.log(
+          `[TTLPlugin] Added ${resourceName}:${record.id} to index (cohort: ${cohort}, granularity: ${config.granularity})`
+        );
+      }
+    } catch (error) {
+      console.error(`[TTLPlugin] Error adding to index:`, error);
+      this.stats.totalErrors++;
+    }
+  }
+  /**
+   * Remove record from expiration index (O(1) using deterministic ID)
+   */
+  async _removeFromIndex(resourceName, recordId) {
+    try {
+      const indexId = `${resourceName}:${recordId}`;
+      const [ok, err] = await tryFn(() => this.expirationIndex.delete(indexId));
+      if (this.verbose && ok) {
+        console.log(`[TTLPlugin] Removed index entry for ${resourceName}:${recordId}`);
+      }
+      if (!ok && err?.code !== "NoSuchKey") {
+        throw err;
+      }
+    } catch (error) {
+      console.error(`[TTLPlugin] Error removing from index:`, error);
+    }
+  }
+  /**
+   * Start interval-based cleanup for each granularity
+   */
+  _startIntervals() {
+    const byGranularity = {
+      minute: [],
+      hour: [],
+      day: [],
+      week: []
+    };
+    for (const [name, config] of Object.entries(this.resources)) {
+      byGranularity[config.granularity].push({ name, config });
+    }
+    for (const [granularity, resources] of Object.entries(byGranularity)) {
+      if (resources.length === 0) continue;
+      const granularityConfig = GRANULARITIES[granularity];
+      const handle = setInterval(
+        () => this._cleanupGranularity(granularity, resources),
+        granularityConfig.interval
+      );
+      this.intervals.push(handle);
+      if (this.verbose) {
+        console.log(
+          `[TTLPlugin] Started ${granularity} interval (${granularityConfig.interval}ms) for ${resources.length} resources`
+        );
+      }
+    }
+    this.isRunning = true;
+  }
+  /**
+   * Stop all intervals
+   */
+  _stopIntervals() {
+    for (const handle of this.intervals) {
+      clearInterval(handle);
+    }
+    this.intervals = [];
+    this.isRunning = false;
+    if (this.verbose) {
+      console.log("[TTLPlugin] Stopped all intervals");
+    }
+  }
+  /**
+   * Cleanup expired records for a specific granularity
+   */
+  async _cleanupGranularity(granularity, resources) {
+    const startTime = Date.now();
+    this.stats.totalScans++;
+    try {
+      const granularityConfig = GRANULARITIES[granularity];
+      const cohorts = getExpiredCohorts(granularity, granularityConfig.cohortsToCheck);
+      if (this.verbose) {
+        console.log(`[TTLPlugin] Cleaning ${granularity} granularity, checking cohorts:`, cohorts);
+      }
+      for (const cohort of cohorts) {
+        const expired = await this.expirationIndex.listPartition({
+          partition: "byExpiresAtCohort",
+          partitionValues: { expiresAtCohort: cohort }
+        });
+        const resourceNames = new Set(resources.map((r) => r.name));
+        const filtered = expired.filter((e) => resourceNames.has(e.resourceName));
+        if (this.verbose && filtered.length > 0) {
+          console.log(`[TTLPlugin] Found ${filtered.length} expired records in cohort ${cohort}`);
+        }
+        for (let i = 0; i < filtered.length; i += this.batchSize) {
+          const batch = filtered.slice(i, i + this.batchSize);
+          for (const entry of batch) {
+            const config = this.resources[entry.resourceName];
+            await this._processExpiredEntry(entry, config);
+          }
+        }
+      }
+      this.stats.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stats.lastScanDuration = Date.now() - startTime;
+      this.emit("scanCompleted", {
+        granularity,
+        duration: this.stats.lastScanDuration,
+        cohorts
+      });
+    } catch (error) {
+      console.error(`[TTLPlugin] Error in ${granularity} cleanup:`, error);
+      this.stats.totalErrors++;
+      this.emit("cleanupError", { granularity, error });
+    }
+  }
+  /**
+   * Process a single expired index entry
+   */
+  async _processExpiredEntry(entry, config) {
+    try {
+      if (!this.database.resources[entry.resourceName]) {
+        if (this.verbose) {
+          console.warn(`[TTLPlugin] Resource "${entry.resourceName}" not found during cleanup, skipping`);
+        }
+        return;
+      }
+      const resource = this.database.resources[entry.resourceName];
+      const [ok, err, record] = await tryFn(() => resource.get(entry.recordId));
+      if (!ok || !record) {
+        await this.expirationIndex.delete(entry.id);
+        return;
+      }
+      if (entry.expiresAtTimestamp && Date.now() < entry.expiresAtTimestamp) {
+        return;
+      }
+      switch (config.onExpire) {
+        case "soft-delete":
+          await this._softDelete(resource, record, config);
+          this.stats.totalSoftDeleted++;
+          break;
+        case "hard-delete":
+          await this._hardDelete(resource, record);
+          this.stats.totalDeleted++;
+          break;
+        case "archive":
+          await this._archive(resource, record, config);
+          this.stats.totalArchived++;
+          this.stats.totalDeleted++;
+          break;
+        case "callback":
+          const shouldDelete = await config.callback(record, resource);
+          this.stats.totalCallbacks++;
+          if (shouldDelete) {
+            await this._hardDelete(resource, record);
+            this.stats.totalDeleted++;
+          }
+          break;
+      }
+      await this.expirationIndex.delete(entry.id);
+      this.stats.totalExpired++;
+      this.emit("recordExpired", { resource: entry.resourceName, record });
+    } catch (error) {
+      console.error(`[TTLPlugin] Error processing expired entry:`, error);
+      this.stats.totalErrors++;
+    }
+  }
+  /**
+   * Soft delete: Mark record as deleted
+   */
+  async _softDelete(resource, record, config) {
+    const deleteField = config.deleteField || "deletedat";
+    const updates = {
+      [deleteField]: (/* @__PURE__ */ new Date()).toISOString(),
+      isdeleted: "true"
+      // Add isdeleted field for partition compatibility
+    };
+    await resource.update(record.id, updates);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Soft-deleted record ${record.id} in ${resource.name}`);
+    }
+  }
+  /**
+   * Hard delete: Remove record from S3
+   */
+  async _hardDelete(resource, record) {
+    await resource.delete(record.id);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Hard-deleted record ${record.id} in ${resource.name}`);
+    }
+  }
+  /**
+   * Archive: Copy to another resource then delete
+   */
+  async _archive(resource, record, config) {
+    if (!this.database.resources[config.archiveResource]) {
+      throw new Error(`Archive resource "${config.archiveResource}" not found`);
+    }
+    const archiveResource = this.database.resources[config.archiveResource];
+    const archiveData = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (!key.startsWith("_")) {
+        archiveData[key] = value;
+      }
+    }
+    archiveData.archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+    archiveData.archivedFrom = resource.name;
+    archiveData.originalId = record.id;
+    if (!config.keepOriginalId) {
+      delete archiveData.id;
+    }
+    await archiveResource.insert(archiveData);
+    await resource.delete(record.id);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Archived record ${record.id} from ${resource.name} to ${config.archiveResource}`);
+    }
+  }
+  /**
+   * Manual cleanup of a specific resource
+   */
+  async cleanupResource(resourceName) {
+    const config = this.resources[resourceName];
+    if (!config) {
+      throw new Error(`Resource "${resourceName}" not configured in TTLPlugin`);
+    }
+    const granularity = config.granularity;
+    await this._cleanupGranularity(granularity, [{ name: resourceName, config }]);
+    return {
+      resource: resourceName,
+      granularity
+    };
+  }
+  /**
+   * Manual cleanup of all resources
+   */
+  async runCleanup() {
+    const byGranularity = {
+      minute: [],
+      hour: [],
+      day: [],
+      week: []
+    };
+    for (const [name, config] of Object.entries(this.resources)) {
+      byGranularity[config.granularity].push({ name, config });
+    }
+    for (const [granularity, resources] of Object.entries(byGranularity)) {
+      if (resources.length > 0) {
+        await this._cleanupGranularity(granularity, resources);
+      }
+    }
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      resources: Object.keys(this.resources).length,
+      isRunning: this.isRunning,
+      intervals: this.intervals.length
+    };
+  }
+  /**
+   * Uninstall the plugin
+   */
+  async uninstall() {
+    this._stopIntervals();
+    await super.uninstall();
+    if (this.verbose) {
+      console.log("[TTLPlugin] Uninstalled");
+    }
+  }
+}
+
 function cosineDistance(a, b) {
   if (a.length !== b.length) {
     throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
@@ -39076,5 +38241,5 @@ var metrics = /*#__PURE__*/Object.freeze({
   silhouetteScore: silhouetteScore
 });
 
-export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, Factory, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, InvalidResourceItem, MemoryCache, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, Seeder, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, generateTypes, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, printTypes, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
+export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, Factory, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, GeoPlugin, InvalidResourceItem, MemoryCache, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, Seeder, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TTLPlugin, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, generateTypes, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, printTypes, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
 //# sourceMappingURL=s3db.es.js.map