s3db.js 12.1.0 → 12.2.1

package/dist/s3db.cjs.js

@@ -5,9 +5,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var crypto$1 = require('crypto');
 var nanoid = require('nanoid');
 var EventEmitter = require('events');
-var hono = require('hono');
-var nodeServer = require('@hono/node-server');
-var swaggerUi = require('@hono/swagger-ui');
 var promises = require('fs/promises');
 var fs = require('fs');
 var promises$1 = require('stream/promises');
@@ -232,8 +229,6 @@ function calculateUTF8Bytes(str) {
 function clearUTF8Memory() {
   utf8BytesMemory.clear();
 }
-const clearUTF8Memo = clearUTF8Memory;
-const clearUTF8Cache = clearUTF8Memory;
 function calculateAttributeNamesSize(mappedObject) {
   let totalSize = 0;
   for (const key of Object.keys(mappedObject)) {
@@ -1627,18 +1622,6 @@ function metadataDecode(value) {
       }
     }
   }
-  const len = value.length;
-  if (len > 0 && len % 4 === 0) {
-    if (/^[A-Za-z0-9+/]+=*$/.test(value)) {
-      try {
-        const decoded = Buffer.from(value, "base64").toString("utf8");
-        if (/[^\x00-\x7F]/.test(decoded) && Buffer.from(decoded, "utf8").toString("base64") === value) {
-          return decoded;
-        }
-      } catch {
-      }
-    }
-  }
   return value;
 }
 
@@ -1725,11 +1708,22 @@ class PluginStorage {
     }
   }
   /**
-   * Alias for set() to maintain backward compatibility
-   * @deprecated Use set() instead
+   * Batch set multiple items
+   *
+   * @param {Array<{key: string, data: Object, options?: Object}>} items - Items to save
+   * @returns {Promise<Array<{ok: boolean, key: string, error?: Error}>>} Results
    */
-  async put(key, data, options = {}) {
-    return this.set(key, data, options);
+  async batchSet(items) {
+    const results = [];
+    for (const item of items) {
+      try {
+        await this.set(item.key, item.data, item.options || {});
+        results.push({ ok: true, key: item.key });
+      } catch (error) {
+        results.push({ ok: false, key: item.key, error });
+      }
+    }
+    return results;
   }
   /**
    * Get data with automatic metadata decoding and TTL check
@@ -2477,1800 +2471,100 @@ 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.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 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 || {};
-  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 || 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
-      };
-      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 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 spec = {
-    openapi: "3.1.0",
-    info: {
-      title,
-      version,
-      description,
-      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;
-  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);
-    spec.tags.push({
-      name,
-      description: `Operations for ${name} resource`
-    });
-    spec.components.schemas[name] = generateResourceSchema(resource);
-  }
-  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.Hono();
-    this.server = null;
-    this.isRunning = false;
-    this.openAPISpec = 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.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();
-    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}`);
-      }
-    }
-  }
-  /**
-   * 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 = nodeServer.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",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/replicator.md",
     dependencies: {
       "pg": {
         version: "^8.0.0",
         description: "PostgreSQL client for Node.js",
-        installCommand: "pnpm add pg"
+        installCommand: "pnpm add pg",
+        npmUrl: "https://www.npmjs.com/package/pg"
       }
     }
   },
   "bigquery-replicator": {
     name: "BigQuery Replicator",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/replicator.md",
     dependencies: {
       "@google-cloud/bigquery": {
         version: "^7.0.0",
         description: "Google Cloud BigQuery SDK",
-        installCommand: "pnpm add @google-cloud/bigquery"
+        installCommand: "pnpm add @google-cloud/bigquery",
+        npmUrl: "https://www.npmjs.com/package/@google-cloud/bigquery"
       }
     }
   },
   "sqs-replicator": {
     name: "SQS Replicator",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/replicator.md",
     dependencies: {
       "@aws-sdk/client-sqs": {
         version: "^3.0.0",
         description: "AWS SDK for SQS",
-        installCommand: "pnpm add @aws-sdk/client-sqs"
+        installCommand: "pnpm add @aws-sdk/client-sqs",
+        npmUrl: "https://www.npmjs.com/package/@aws-sdk/client-sqs"
       }
     }
   },
   "sqs-consumer": {
     name: "SQS Queue Consumer",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/queue-consumer.md",
     dependencies: {
       "@aws-sdk/client-sqs": {
         version: "^3.0.0",
         description: "AWS SDK for SQS",
-        installCommand: "pnpm add @aws-sdk/client-sqs"
+        installCommand: "pnpm add @aws-sdk/client-sqs",
+        npmUrl: "https://www.npmjs.com/package/@aws-sdk/client-sqs"
       }
     }
   },
   "rabbitmq-consumer": {
     name: "RabbitMQ Queue Consumer",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/queue-consumer.md",
     dependencies: {
       "amqplib": {
         version: "^0.10.0",
         description: "AMQP 0-9-1 library for RabbitMQ",
-        installCommand: "pnpm add amqplib"
+        installCommand: "pnpm add amqplib",
+        npmUrl: "https://www.npmjs.com/package/amqplib"
       }
     }
   },
   "tfstate-plugin": {
-    name: "Terraform State Plugin",
+    name: "Tfstate Plugin",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/tfstate.md",
     dependencies: {
       "node-cron": {
         version: "^4.0.0",
         description: "Cron job scheduler for auto-sync functionality",
-        installCommand: "pnpm add node-cron"
+        installCommand: "pnpm add node-cron",
+        npmUrl: "https://www.npmjs.com/package/node-cron"
       }
     }
   },
   "api-plugin": {
     name: "API Plugin",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/api.md",
     dependencies: {
       "hono": {
         version: "^4.0.0",
         description: "Ultra-light HTTP server framework",
-        installCommand: "pnpm add hono"
+        installCommand: "pnpm add hono",
+        npmUrl: "https://www.npmjs.com/package/hono"
       },
       "@hono/node-server": {
         version: "^1.0.0",
         description: "Node.js adapter for Hono",
-        installCommand: "pnpm add @hono/node-server"
+        installCommand: "pnpm add @hono/node-server",
+        npmUrl: "https://www.npmjs.com/package/@hono/node-server"
       },
       "@hono/swagger-ui": {
         version: "^0.4.0",
         description: "Swagger UI integration for Hono",
-        installCommand: "pnpm add @hono/swagger-ui"
+        installCommand: "pnpm add @hono/swagger-ui",
+        npmUrl: "https://www.npmjs.com/package/@hono/swagger-ui"
       }
     }
   }
@@ -4356,21 +2650,55 @@ async function requirePluginDependency(pluginId, options = {}) {
   }
   const valid = missing.length === 0 && incompatible.length === 0;
   if (!valid && throwOnError) {
+    const depCount = Object.keys(pluginDef.dependencies).length;
+    const missingCount = missing.length;
+    const incompatCount = incompatible.length;
     const errorMsg = [
-      `
-${pluginDef.name} - Missing dependencies detected!
-`,
-      `Plugin ID: ${pluginId}`,
       "",
+      "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+      `\u2551  \u274C ${pluginDef.name} - Missing Dependencies  \u2551`,
+      "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D",
+      "",
+      `\u{1F4E6} Plugin: ${pluginId}`,
+      `\u{1F4CA} Status: ${depCount - missingCount - incompatCount}/${depCount} dependencies satisfied`,
+      "",
+      "\u{1F50D} Dependency Status:",
+      "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
       ...messages,
       "",
-      "Quick fix - Run all install commands:",
-      Object.values(pluginDef.dependencies).map((dep) => `  ${dep.installCommand}`).join("\n"),
+      "\u{1F680} Quick Fix - Install Missing Dependencies:",
+      "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "",
+      "  Option 1: Install individually",
+      ...Object.entries(pluginDef.dependencies).filter(([pkg]) => missing.includes(pkg) || incompatible.includes(pkg)).map(([pkg, info]) => `    ${info.installCommand}`),
+      "",
+      "  Option 2: Install all at once",
+      `    pnpm add ${Object.keys(pluginDef.dependencies).join(" ")}`,
       "",
-      "Or install all peer dependencies at once:",
-      `  pnpm add ${Object.keys(pluginDef.dependencies).join(" ")}`
+      "\u{1F4DA} Documentation:",
+      `    ${pluginDef.docsUrl}`,
+      "",
+      "\u{1F4A1} Troubleshooting:",
+      "  \u2022 If packages are installed but not detected, try:",
+      "    1. Delete node_modules and reinstall: rm -rf node_modules && pnpm install",
+      "    2. Check Node.js version: node --version (requires Node 18+)",
+      "    3. Verify pnpm version: pnpm --version (requires pnpm 8+)",
+      "",
+      "  \u2022 Still having issues? Check:",
+      "    - Package.json has correct dependencies listed",
+      "    - No conflicting versions in pnpm-lock.yaml",
+      "    - File permissions (especially in node_modules/)",
+      "",
+      "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+      ""
     ].join("\n");
-    throw new Error(errorMsg);
+    const error = new Error(errorMsg);
+    error.pluginId = pluginId;
+    error.pluginName = pluginDef.name;
+    error.missing = missing;
+    error.incompatible = incompatible;
+    error.docsUrl = pluginDef.docsUrl;
+    throw error;
   }
   return { valid, missing, incompatible, messages };
 }
@@ -4387,7 +2715,6 @@ class ApiPlugin extends Plugin {
       port: options.port || 3e3,
       host: options.host || "0.0.0.0",
       verbose: options.verbose || false,
-      // API Documentation (supports both new and legacy formats)
       docs: {
         enabled: options.docs?.enabled !== false && options.docsEnabled !== false,
         // Enable by default
@@ -4704,6 +3031,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,
@@ -5766,8 +4098,6 @@ class MultiBackupDriver extends BaseBackupDriver {
       strategy: "all",
       // 'all', 'any', 'priority'
       concurrency: 3,
-      requireAll: true,
-      // For backward compatibility
       ...config
     });
     this.drivers = [];
@@ -6404,13 +4734,13 @@ class BackupPlugin extends Plugin {
       createdAt: now.toISOString().slice(0, 10)
     };
     const [ok] = await tryFn(
-      () => this.database.resource(this.config.backupMetadataResource).insert(metadata)
+      () => this.database.resources[this.config.backupMetadataResource].insert(metadata)
     );
     return metadata;
   }
   async _updateBackupMetadata(backupId, updates) {
     const [ok] = await tryFn(
-      () => this.database.resource(this.config.backupMetadataResource).update(backupId, updates)
+      () => this.database.resources[this.config.backupMetadataResource].update(backupId, updates)
     );
   }
   async _createBackupManifest(type, options) {
@@ -6445,7 +4775,7 @@ class BackupPlugin extends Plugin {
     let sinceTimestamp = null;
     if (type === "incremental") {
       const [lastBackupOk, , lastBackups] = await tryFn(
-        () => this.database.resource(this.config.backupMetadataResource).list({
+        () => this.database.resources[this.config.backupMetadataResource].list({
           filter: {
             status: "completed",
             type: { $in: ["full", "incremental"] }
@@ -6753,7 +5083,7 @@ class BackupPlugin extends Plugin {
     try {
       const driverBackups = await this.driver.list(options);
       const [metaOk, , metadataRecords] = await tryFn(
-        () => this.database.resource(this.config.backupMetadataResource).list({
+        () => this.database.resources[this.config.backupMetadataResource].list({
           limit: options.limit || 50,
           sort: { timestamp: -1 }
         })
@@ -6781,14 +5111,14 @@ class BackupPlugin extends Plugin {
    */
   async getBackupStatus(backupId) {
     const [ok, , backup] = await tryFn(
-      () => this.database.resource(this.config.backupMetadataResource).get(backupId)
+      () => this.database.resources[this.config.backupMetadataResource].get(backupId)
     );
     return ok ? backup : null;
   }
   async _cleanupOldBackups() {
     try {
       const [listOk, , allBackups] = await tryFn(
-        () => this.database.resource(this.config.backupMetadataResource).list({
+        () => this.database.resources[this.config.backupMetadataResource].list({
           filter: { status: "completed" },
           sort: { timestamp: -1 }
         })
@@ -6855,7 +5185,7 @@ class BackupPlugin extends Plugin {
       for (const backup of backupsToDelete) {
         try {
           await this.driver.delete(backup.id, backup.driverInfo);
-          await this.database.resource(this.config.backupMetadataResource).delete(backup.id);
+          await this.database.resources[this.config.backupMetadataResource].delete(backup.id);
           if (this.config.verbose) {
             console.log(`[BackupPlugin] Deleted old backup: ${backup.id}`);
           }
@@ -6891,12 +5221,6 @@ class BackupPlugin extends Plugin {
       await this.driver.cleanup();
     }
   }
-  /**
-   * Cleanup plugin resources (alias for stop for backward compatibility)
-   */
-  async cleanup() {
-    await this.stop();
-  }
 }
 
 class CacheError extends S3dbError {
@@ -9792,9 +8116,6 @@ async function consolidateRecord(originalId, transactionResource, targetResource
         if (txnWithCohorts.cohortMonth && !txn.cohortMonth) {
           updateData.cohortMonth = txnWithCohorts.cohortMonth;
         }
-        if (txn.value === null || txn.value === void 0) {
-          updateData.value = 1;
-        }
         const [ok2, err2] = await tryFn(
           () => transactionResource.update(txn.id, updateData)
         );
@@ -11118,8 +9439,7 @@ async function completeFieldSetup(handler, database, config, plugin) {
         operation: "string|required",
         timestamp: "string|required",
         cohortDate: "string|required",
-        cohortHour: "string|optional",
-        // ✅ FIX BUG #2: Changed from required to optional for migration compatibility
+        cohortHour: "string|required",
         cohortWeek: "string|optional",
         cohortMonth: "string|optional",
         source: "string|optional",
@@ -13453,7 +11773,7 @@ class RelationPlugin extends Plugin {
    * @private
    */
   async _setupResourceRelations(resourceName, relationsDef) {
-    const resource = this.database.resource(resourceName);
+    const resource = this.database.resources[resourceName];
     if (!resource) {
       if (this.verbose) {
         console.warn(`[RelationPlugin] Resource "${resourceName}" not found, will setup when created`);
@@ -13564,7 +11884,7 @@ class RelationPlugin extends Plugin {
         for (const record of records) {
           const relatedData = record[relationName];
           if (relatedData) {
-            const relatedResource = this.database.resource(config.resource);
+            const relatedResource = this.database.resources[config.resource];
             const relatedArray = Array.isArray(relatedData) ? relatedData : [relatedData];
             if (relatedArray.length > 0) {
               await this._eagerLoad(relatedArray, nestedIncludes, relatedResource);
@@ -13615,7 +11935,7 @@ class RelationPlugin extends Plugin {
    * @private
    */
   async _loadHasOne(records, relationName, config, sourceResource) {
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       throw new RelatedResourceNotFoundError(config.resource, {
         sourceResource: sourceResource.name,
@@ -13654,7 +11974,7 @@ class RelationPlugin extends Plugin {
    * @private
    */
   async _loadHasMany(records, relationName, config, sourceResource) {
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       throw new RelatedResourceNotFoundError(config.resource, {
         sourceResource: sourceResource.name,
@@ -13700,7 +12020,7 @@ class RelationPlugin extends Plugin {
    * @private
    */
   async _loadBelongsTo(records, relationName, config, sourceResource) {
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       throw new RelatedResourceNotFoundError(config.resource, {
         sourceResource: sourceResource.name,
@@ -13750,14 +12070,14 @@ class RelationPlugin extends Plugin {
    * @private
    */
   async _loadBelongsToMany(records, relationName, config, sourceResource) {
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       throw new RelatedResourceNotFoundError(config.resource, {
         sourceResource: sourceResource.name,
         relation: relationName
       });
     }
-    const junctionResource = this.database.resource(config.through);
+    const junctionResource = this.database.resources[config.through];
     if (!junctionResource) {
       throw new JunctionTableNotFoundError(config.through, {
         sourceResource: sourceResource.name,
@@ -13941,7 +12261,7 @@ class RelationPlugin extends Plugin {
    */
   async _cascadeDelete(record, resource, relationName, config) {
     this.stats.cascadeOperations++;
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       throw new RelatedResourceNotFoundError(config.resource, {
         sourceResource: resource.name,
@@ -13949,7 +12269,7 @@ class RelationPlugin extends Plugin {
       });
     }
     const deletedRecords = [];
-    config.type === "belongsToMany" ? this.database.resource(config.through) : null;
+    config.type === "belongsToMany" ? this.database.resources[config.through] : null;
     try {
       if (config.type === "hasMany") {
         let relatedRecords;
@@ -14000,7 +12320,7 @@ class RelationPlugin extends Plugin {
           await relatedResource.delete(relatedRecords[0].id);
         }
       } else if (config.type === "belongsToMany") {
-        const junctionResource2 = this.database.resource(config.through);
+        const junctionResource2 = this.database.resources[config.through];
         if (junctionResource2) {
           let junctionRecords;
           const partitionName = this._findPartitionByField(junctionResource2, config.foreignKey);
@@ -14068,7 +12388,7 @@ class RelationPlugin extends Plugin {
    */
   async _cascadeUpdate(record, changes, resource, relationName, config) {
     this.stats.cascadeOperations++;
-    const relatedResource = this.database.resource(config.resource);
+    const relatedResource = this.database.resources[config.resource];
     if (!relatedResource) {
       return;
     }
@@ -19353,12 +17673,42 @@ ${errorDetails}`,
       createdBy
     };
     this.hooks = {
+      // Insert hooks
       beforeInsert: [],
       afterInsert: [],
+      // Update hooks
       beforeUpdate: [],
       afterUpdate: [],
+      // Delete hooks
       beforeDelete: [],
-      afterDelete: []
+      afterDelete: [],
+      // Get hooks
+      beforeGet: [],
+      afterGet: [],
+      // List hooks
+      beforeList: [],
+      afterList: [],
+      // Query hooks
+      beforeQuery: [],
+      afterQuery: [],
+      // Patch hooks
+      beforePatch: [],
+      afterPatch: [],
+      // Replace hooks
+      beforeReplace: [],
+      afterReplace: [],
+      // Exists hooks
+      beforeExists: [],
+      afterExists: [],
+      // Count hooks
+      beforeCount: [],
+      afterCount: [],
+      // GetMany hooks
+      beforeGetMany: [],
+      afterGetMany: [],
+      // DeleteMany hooks
+      beforeDeleteMany: [],
+      afterDeleteMany: []
     };
     this.attributes = attributes || {};
     this.map = config.map;
@@ -19421,19 +17771,6 @@ ${errorDetails}`,
     }
     return idSize;
   }
-  /**
-   * Get resource options (for backward compatibility with tests)
-   */
-  get options() {
-    return {
-      timestamps: this.config.timestamps,
-      partitions: this.config.partitions || {},
-      cache: this.config.cache,
-      autoDecrypt: this.config.autoDecrypt,
-      paranoid: this.config.paranoid,
-      allNestedObjectsOptional: this.config.allNestedObjectsOptional
-    };
-  }
   export() {
     const exported = this.schema.export();
     exported.behavior = this.behavior;
@@ -19560,19 +17897,71 @@ ${errorDetails}`,
       return data;
     });
   }
-  async validate(data) {
+  /**
+   * Validate data against resource schema without saving
+   * @param {Object} data - Data to validate
+   * @param {Object} options - Validation options
+   * @param {boolean} options.throwOnError - Throw error if validation fails (default: false)
+   * @param {boolean} options.includeId - Include ID validation (default: false)
+   * @param {boolean} options.mutateOriginal - Allow mutation of original data (default: false)
+   * @returns {Promise<{valid: boolean, isValid: boolean, errors: Array, data: Object, original: Object}>} Validation result
+   * @example
+   * // Validate before insert
+   * const result = await resource.validate({
+   *   name: 'John Doe',
+   *   email: 'invalid-email' // Will fail email validation
+   * });
+   *
+   * if (!result.valid) {
+   *   console.log('Validation errors:', result.errors);
+   *   // [{ field: 'email', message: '...', ... }]
+   * }
+   *
+   * // Throw on error
+   * try {
+   *   await resource.validate({ email: 'bad' }, { throwOnError: true });
+   * } catch (err) {
+   *   console.log('Validation failed:', err.message);
+   * }
+   */
+  async validate(data, options = {}) {
+    const {
+      throwOnError = false,
+      includeId = false,
+      mutateOriginal = false
+    } = options;
+    const dataToValidate = mutateOriginal ? data : lodashEs.cloneDeep(data);
+    if (!includeId && dataToValidate.id) {
+      delete dataToValidate.id;
+    }
     const result = {
       original: lodashEs.cloneDeep(data),
       isValid: false,
-      errors: []
+      errors: [],
+      data: dataToValidate
     };
-    const check = await this.schema.validate(data, { mutateOriginal: false });
-    if (check === true) {
-      result.isValid = true;
-    } else {
-      result.errors = check;
+    try {
+      const check = await this.schema.validate(dataToValidate, { mutateOriginal });
+      if (check === true) {
+        result.isValid = true;
+      } else {
+        result.errors = Array.isArray(check) ? check : [check];
+        result.isValid = false;
+        if (throwOnError) {
+          const error = new Error("Validation failed");
+          error.validationErrors = result.errors;
+          error.invalidData = data;
+          throw error;
+        }
+      }
+    } catch (err) {
+      if (!throwOnError) {
+        result.errors = [{ message: err.message, error: err }];
+        result.isValid = false;
+      } else {
+        throw err;
+      }
     }
-    result.data = data;
     return result;
   }
   /**
@@ -19837,12 +18226,12 @@ ${errorDetails}`,
     const exists = await this.exists(id$1);
     if (exists) throw new Error(`Resource with id '${id$1}' already exists`);
     this.getResourceKey(id$1 || "(auto)");
-    if (this.options.timestamps) {
+    if (this.config.timestamps) {
       attributes.createdAt = (/* @__PURE__ */ new Date()).toISOString();
       attributes.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     }
     const attributesWithDefaults = this.applyDefaults(attributes);
-    const completeData = { id: id$1, ...attributesWithDefaults };
+    const completeData = id$1 !== void 0 ? { id: id$1, ...attributesWithDefaults } : { ...attributesWithDefaults };
     const preProcessedData = await this.executeHooks("beforeInsert", completeData);
     const extraProps = Object.keys(preProcessedData).filter(
       (k) => !(k in completeData) || preProcessedData[k] !== completeData[k]
@@ -19853,7 +18242,7 @@ ${errorDetails}`,
       errors,
       isValid,
       data: validated
-    } = await this.validate(preProcessedData);
+    } = await this.validate(preProcessedData, { includeId: true });
     if (!isValid) {
       const errorMsg = errors && errors.length && errors[0].message ? errors[0].message : "Insert failed";
       throw new InvalidResourceItem({
@@ -19957,6 +18346,7 @@ ${errorDetails}`,
   async get(id) {
     if (lodashEs.isObject(id)) throw new Error(`id cannot be an object`);
     if (lodashEs.isEmpty(id)) throw new Error("id cannot be empty");
+    await this.executeHooks("beforeGet", { id });
     const key = this.getResourceKey(id);
     const [ok, err, request] = await tryFn(() => this.client.getObject(key));
     if (!ok) {
@@ -20005,17 +18395,67 @@ ${errorDetails}`,
     if (objectVersion !== this.version) {
       data = await this.applyVersionMapping(data, objectVersion, this.version);
     }
+    data = await this.executeHooks("afterGet", data);
     this.emit("get", data);
     const value = data;
     return value;
   }
+  /**
+   * Retrieve a resource object by ID, or return null if not found
+   * @param {string} id - Resource ID
+   * @returns {Promise<Object|null>} The resource object or null if not found
+   * @example
+   * const user = await resource.getOrNull('user-123');
+   * if (user) {
+   *   console.log('Found user:', user.name);
+   * } else {
+   *   console.log('User not found');
+   * }
+   */
+  async getOrNull(id) {
+    const [ok, err, data] = await tryFn(() => this.get(id));
+    if (!ok && err && (err.name === "NoSuchKey" || err.message?.includes("NoSuchKey"))) {
+      return null;
+    }
+    if (!ok) {
+      throw err;
+    }
+    return data;
+  }
+  /**
+   * Retrieve a resource object by ID, or throw ResourceNotFoundError if not found
+   * @param {string} id - Resource ID
+   * @returns {Promise<Object>} The resource object
+   * @throws {ResourceError} If resource does not exist
+   * @example
+   * // Throws error if user doesn't exist (no need for null check)
+   * const user = await resource.getOrThrow('user-123');
+   * console.log('User name:', user.name); // Safe to access
+   */
+  async getOrThrow(id) {
+    const [ok, err, data] = await tryFn(() => this.get(id));
+    if (!ok && err && (err.name === "NoSuchKey" || err.message?.includes("NoSuchKey"))) {
+      throw new ResourceError(`Resource '${this.name}' with id '${id}' not found`, {
+        resourceName: this.name,
+        operation: "getOrThrow",
+        id,
+        code: "RESOURCE_NOT_FOUND"
+      });
+    }
+    if (!ok) {
+      throw err;
+    }
+    return data;
+  }
   /**
    * Check if a resource exists by ID
    * @returns {Promise<boolean>} True if resource exists, false otherwise
    */
   async exists(id) {
+    await this.executeHooks("beforeExists", { id });
     const key = this.getResourceKey(id);
     const [ok, err] = await tryFn(() => this.client.headObject(key));
+    await this.executeHooks("afterExists", { id, exists: ok });
     return ok;
   }
   /**
@@ -20071,7 +18511,7 @@ ${errorDetails}`,
     }
     const preProcessedData = await this.executeHooks("beforeUpdate", lodashEs.cloneDeep(mergedData));
     const completeData = { ...originalData, ...preProcessedData, id };
-    const { isValid, errors, data } = await this.validate(lodashEs.cloneDeep(completeData));
+    const { isValid, errors, data } = await this.validate(lodashEs.cloneDeep(completeData), { includeId: true });
     if (!isValid) {
       throw new InvalidResourceItem({
         bucket: this.client.config.bucket,
@@ -20244,12 +18684,17 @@ ${errorDetails}`,
     if (!fields || typeof fields !== "object") {
       throw new Error("fields must be a non-empty object");
     }
+    await this.executeHooks("beforePatch", { id, fields, options });
     const behavior = this.behavior;
     const hasNestedFields = Object.keys(fields).some((key) => key.includes("."));
+    let result;
     if ((behavior === "enforce-limits" || behavior === "truncate-data") && !hasNestedFields) {
-      return await this._patchViaCopyObject(id, fields, options);
+      result = await this._patchViaCopyObject(id, fields, options);
+    } else {
+      result = await this.update(id, fields, options);
     }
-    return await this.update(id, fields, options);
+    const finalResult = await this.executeHooks("afterPatch", result);
+    return finalResult;
   }
   /**
    * Internal helper: Optimized patch using HeadObject + CopyObject
@@ -20349,6 +18794,7 @@ ${errorDetails}`,
     if (!fullData || typeof fullData !== "object") {
       throw new Error("fullData must be a non-empty object");
     }
+    await this.executeHooks("beforeReplace", { id, fullData, options });
     const { partition, partitionValues } = options;
     const dataClone = lodashEs.cloneDeep(fullData);
     const attributesWithDefaults = this.applyDefaults(dataClone);
@@ -20363,7 +18809,7 @@ ${errorDetails}`,
       errors,
       isValid,
       data: validated
-    } = await this.validate(completeData);
+    } = await this.validate(completeData, { includeId: true });
     if (!isValid) {
       const errorMsg = errors && errors.length && errors[0].message ? errors[0].message : "Replace failed";
       throw new InvalidResourceItem({
@@ -20436,7 +18882,8 @@ ${errorDetails}`,
         await this.handlePartitionReferenceUpdates({}, replacedObject);
       }
     }
-    return replacedObject;
+    const finalResult = await this.executeHooks("afterReplace", replacedObject);
+    return finalResult;
   }
   /**
    * Update with conditional check (If-Match ETag)
@@ -20494,7 +18941,7 @@ ${errorDetails}`,
     }
     const preProcessedData = await this.executeHooks("beforeUpdate", lodashEs.cloneDeep(mergedData));
     const completeData = { ...originalData, ...preProcessedData, id };
-    const { isValid, errors, data } = await this.validate(lodashEs.cloneDeep(completeData));
+    const { isValid, errors, data } = await this.validate(lodashEs.cloneDeep(completeData), { includeId: true });
     if (!isValid) {
       return {
         success: false,
@@ -20715,6 +19162,7 @@ ${errorDetails}`,
    * });
    */
   async count({ partition = null, partitionValues = {} } = {}) {
+    await this.executeHooks("beforeCount", { partition, partitionValues });
     let prefix;
     if (partition && Object.keys(partitionValues).length > 0) {
       const partitionDef = this.config.partitions[partition];
@@ -20739,6 +19187,7 @@ ${errorDetails}`,
       prefix = `resource=${this.name}/data`;
     }
     const count = await this.client.count({ prefix });
+    await this.executeHooks("afterCount", { count, partition, partitionValues });
     this.emit("count", count);
     return count;
   }
@@ -20774,6 +19223,7 @@ ${errorDetails}`,
    * const results = await resource.deleteMany(deletedIds);
       */
   async deleteMany(ids) {
+    await this.executeHooks("beforeDeleteMany", { ids });
     const packages = lodashEs.chunk(
       ids.map((id) => this.getResourceKey(id)),
       1e3
@@ -20795,6 +19245,7 @@ ${errorDetails}`,
       });
       return response;
     });
+    await this.executeHooks("afterDeleteMany", { ids, results });
     this.emit("deleteMany", ids.length);
     return results;
   }
@@ -20916,6 +19367,7 @@ ${errorDetails}`,
    * });
    */
   async list({ partition = null, partitionValues = {}, limit, offset = 0 } = {}) {
+    await this.executeHooks("beforeList", { partition, partitionValues, limit, offset });
     const [ok, err, result] = await tryFn(async () => {
       if (!partition) {
         return await this.listMain({ limit, offset });
@@ -20925,7 +19377,8 @@ ${errorDetails}`,
     if (!ok) {
       return this.handleListError(err, { partition, partitionValues });
     }
-    return result;
+    const finalResult = await this.executeHooks("afterList", result);
+    return finalResult;
   }
   async listMain({ limit, offset = 0 }) {
     const [ok, err, ids] = await tryFn(() => this.listIds({ limit, offset }));
@@ -21068,6 +19521,7 @@ ${errorDetails}`,
    * const users = await resource.getMany(['user-1', 'user-2', 'user-3']);
       */
   async getMany(ids) {
+    await this.executeHooks("beforeGetMany", { ids });
     const { results, errors } = await promisePool.PromisePool.for(ids).withConcurrency(this.client.parallelism).handleError(async (error, id) => {
       this.emit("error", error, content);
       this.observers.map((x) => x.emit("error", this.name, error, content));
@@ -21088,8 +19542,9 @@ ${errorDetails}`,
       }
       throw err;
     });
+    const finalResults = await this.executeHooks("afterGetMany", results);
     this.emit("getMany", ids.length);
-    return results;
+    return finalResults;
   }
   /**
    * Get all resources (equivalent to list() without pagination)
@@ -21336,21 +19791,6 @@ ${errorDetails}`,
    * @returns {Object} Schema object for the version
    */
   async getSchemaForVersion(version) {
-    if (version === this.version) {
-      return this.schema;
-    }
-    const [ok, err, compatibleSchema] = await tryFn(() => Promise.resolve(new Schema({
-      name: this.name,
-      attributes: this.attributes,
-      passphrase: this.passphrase,
-      version,
-      options: {
-        ...this.config,
-        autoDecrypt: true,
-        autoEncrypt: true
-      }
-    })));
-    if (ok) return compatibleSchema;
     return this.schema;
   }
   /**
@@ -21446,6 +19886,7 @@ ${errorDetails}`,
    * );
    */
   async query(filter = {}, { limit = 100, offset = 0, partition = null, partitionValues = {} } = {}) {
+    await this.executeHooks("beforeQuery", { filter, limit, offset, partition, partitionValues });
     if (Object.keys(filter).length === 0) {
       return await this.list({ partition, partitionValues, limit, offset });
     }
@@ -21473,7 +19914,8 @@ ${errorDetails}`,
         break;
       }
     }
-    return results.slice(0, limit);
+    const finalResults = results.slice(0, limit);
+    return await this.executeHooks("afterQuery", finalResults);
   }
   /**
    * Handle partition reference updates with change detection
@@ -21553,7 +19995,7 @@ ${errorDetails}`,
     }
   }
   /**
-   * Update partition objects to keep them in sync (legacy method for backward compatibility)
+   * Update partition objects to keep them in sync
    * @param {Object} data - Updated object data
    */
   async updatePartitionReferences(data) {
@@ -21939,7 +20381,32 @@ function validateResourceConfig(config) {
     if (typeof config.hooks !== "object" || Array.isArray(config.hooks)) {
       errors.push("Resource 'hooks' must be an object");
     } else {
-      const validHookEvents = ["beforeInsert", "afterInsert", "beforeUpdate", "afterUpdate", "beforeDelete", "afterDelete"];
+      const validHookEvents = [
+        "beforeInsert",
+        "afterInsert",
+        "beforeUpdate",
+        "afterUpdate",
+        "beforeDelete",
+        "afterDelete",
+        "beforeGet",
+        "afterGet",
+        "beforeList",
+        "afterList",
+        "beforeQuery",
+        "afterQuery",
+        "beforeExists",
+        "afterExists",
+        "beforeCount",
+        "afterCount",
+        "beforePatch",
+        "afterPatch",
+        "beforeReplace",
+        "afterReplace",
+        "beforeGetMany",
+        "afterGetMany",
+        "beforeDeleteMany",
+        "afterDeleteMany"
+      ];
       for (const [event, hooksArr] of Object.entries(config.hooks)) {
         if (!validHookEvents.includes(event)) {
           errors.push(`Invalid hook event '${event}'. Valid events: ${validHookEvents.join(", ")}`);
@@ -21987,17 +20454,35 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.1.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.2.1" : "latest");
       return ok ? version : "latest";
     })();
-    this.resources = {};
+    this._resourcesMap = {};
+    this.resources = new Proxy(this._resourcesMap, {
+      get: (target, prop) => {
+        if (typeof prop === "symbol" || prop === "constructor" || prop === "toJSON") {
+          return target[prop];
+        }
+        if (target[prop]) {
+          return target[prop];
+        }
+        return void 0;
+      },
+      // Support Object.keys(), Object.entries(), etc.
+      ownKeys: (target) => {
+        return Object.keys(target);
+      },
+      getOwnPropertyDescriptor: (target, prop) => {
+        return Object.getOwnPropertyDescriptor(target, prop);
+      }
+    });
     this.savedMetadata = null;
     this.options = options;
     this.verbose = options.verbose || false;
     this.parallelism = parseInt(options.parallelism + "") || 10;
-    this.plugins = options.plugins || [];
-    this.pluginRegistry = {};
     this.pluginList = options.plugins || [];
+    this.pluginRegistry = {};
+    this.plugins = this.pluginRegistry;
     this.cache = options.cache;
     this.passphrase = options.passphrase || "secret";
     this.versioningEnabled = options.versioningEnabled || false;
@@ -22103,7 +20588,7 @@ class Database extends EventEmitter {
         } else {
           restoredIdSize = versionData.idSize || 22;
         }
-        this.resources[name] = new Resource({
+        this._resourcesMap[name] = new Resource({
           name,
           client: this.client,
           database: this,
@@ -22172,7 +20657,7 @@ class Database extends EventEmitter {
       }
     }
     for (const [name, savedResource] of Object.entries(savedMetadata.resources || {})) {
-      if (!this.resources[name]) {
+      if (!this._resourcesMap[name]) {
         const currentVersion = savedResource.currentVersion || "v1";
         const versionData = savedResource.versions?.[currentVersion];
         changes.push({
@@ -22684,7 +21169,7 @@ class Database extends EventEmitter {
    * @returns {boolean} True if resource exists, false otherwise
    */
   resourceExists(name) {
-    return !!this.resources[name];
+    return !!this._resourcesMap[name];
   }
   /**
    * Check if a resource exists with the same definition hash
@@ -22692,14 +21177,13 @@ class Database extends EventEmitter {
    * @param {string} config.name - Resource name
    * @param {Object} config.attributes - Resource attributes
    * @param {string} [config.behavior] - Resource behavior
-   * @param {Object} [config.options] - Resource options (deprecated, use root level parameters)
    * @returns {Object} Result with exists and hash information
    */
-  resourceExistsWithSameHash({ name, attributes, behavior = "user-managed", partitions = {}, options = {} }) {
-    if (!this.resources[name]) {
+  resourceExistsWithSameHash({ name, attributes, behavior = "user-managed", partitions = {} }) {
+    if (!this._resourcesMap[name]) {
       return { exists: false, sameHash: false, hash: null };
     }
-    const existingResource = this.resources[name];
+    const existingResource = this._resourcesMap[name];
     const existingHash = this.generateDefinitionHash(existingResource.export());
     const mockResource = new Resource({
       name,
@@ -22709,8 +21193,7 @@ class Database extends EventEmitter {
       client: this.client,
       version: existingResource.version,
       passphrase: this.passphrase,
-      versioningEnabled: this.versioningEnabled,
-      ...options
+      versioningEnabled: this.versioningEnabled
     });
     const newHash = this.generateDefinitionHash(mockResource.export());
     return {
@@ -22738,12 +21221,49 @@ class Database extends EventEmitter {
    * @param {string} [config.createdBy='user'] - Who created this resource ('user', 'plugin', or plugin name)
    * @returns {Promise<Resource>} The created or updated resource
    */
-  async createResource({ name, attributes, behavior = "user-managed", hooks, ...config }) {
-    if (this.resources[name]) {
-      const existingResource = this.resources[name];
+  /**
+   * Normalize partitions config from array or object format
+   * @param {Array|Object} partitions - Partitions config
+   * @param {Object} attributes - Resource attributes
+   * @returns {Object} Normalized partitions object
+   * @private
+   */
+  _normalizePartitions(partitions, attributes) {
+    if (!Array.isArray(partitions)) {
+      return partitions || {};
+    }
+    const normalized = {};
+    for (const fieldName of partitions) {
+      if (typeof fieldName !== "string") {
+        throw new Error(`Partition field must be a string, got ${typeof fieldName}`);
+      }
+      if (!attributes[fieldName]) {
+        throw new Error(`Partition field '${fieldName}' not found in attributes`);
+      }
+      const partitionName = `by${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
+      const fieldDef = attributes[fieldName];
+      let fieldType = "string";
+      if (typeof fieldDef === "string") {
+        fieldType = fieldDef.split("|")[0].trim();
+      } else if (typeof fieldDef === "object" && fieldDef.type) {
+        fieldType = fieldDef.type;
+      }
+      normalized[partitionName] = {
+        fields: {
+          [fieldName]: fieldType
+        }
+      };
+    }
+    return normalized;
+  }
+  async createResource({ name, attributes, behavior = "user-managed", hooks, middlewares, ...config }) {
+    const normalizedPartitions = this._normalizePartitions(config.partitions, attributes);
+    if (this._resourcesMap[name]) {
+      const existingResource = this._resourcesMap[name];
       Object.assign(existingResource.config, {
         cache: this.cache,
-        ...config
+        ...config,
+        partitions: normalizedPartitions
       });
       if (behavior) {
         existingResource.behavior = behavior;
@@ -22761,6 +21281,9 @@ class Database extends EventEmitter {
           }
         }
       }
+      if (middlewares) {
+        this._applyMiddlewares(existingResource, middlewares);
+      }
       const newHash = this.generateDefinitionHash(existingResource.export(), existingResource.behavior);
       const existingMetadata2 = this.savedMetadata?.resources?.[name];
       const currentVersion = existingMetadata2?.currentVersion || "v1";
@@ -22784,7 +21307,7 @@ class Database extends EventEmitter {
       observers: [this],
       cache: config.cache !== void 0 ? config.cache : this.cache,
       timestamps: config.timestamps !== void 0 ? config.timestamps : false,
-      partitions: config.partitions || {},
+      partitions: normalizedPartitions,
       paranoid: config.paranoid !== void 0 ? config.paranoid : true,
       allNestedObjectsOptional: config.allNestedObjectsOptional !== void 0 ? config.allNestedObjectsOptional : true,
       autoDecrypt: config.autoDecrypt !== void 0 ? config.autoDecrypt : true,
@@ -22800,16 +21323,96 @@ class Database extends EventEmitter {
       createdBy: config.createdBy || "user"
     });
     resource.database = this;
-    this.resources[name] = resource;
+    this._resourcesMap[name] = resource;
+    if (middlewares) {
+      this._applyMiddlewares(resource, middlewares);
+    }
     await this.uploadMetadataFile();
     this.emit("s3db.resourceCreated", name);
     return resource;
   }
-  resource(name) {
-    if (!this.resources[name]) {
-      return Promise.reject(`resource ${name} does not exist`);
+  /**
+   * Apply middlewares to a resource
+   * @param {Resource} resource - Resource instance
+   * @param {Array|Object} middlewares - Middlewares config
+   * @private
+   */
+  _applyMiddlewares(resource, middlewares) {
+    if (Array.isArray(middlewares)) {
+      const methods = resource._middlewareMethods || [
+        "get",
+        "list",
+        "listIds",
+        "getAll",
+        "count",
+        "page",
+        "insert",
+        "update",
+        "delete",
+        "deleteMany",
+        "exists",
+        "getMany",
+        "content",
+        "hasContent",
+        "query",
+        "getFromPartition",
+        "setContent",
+        "deleteContent",
+        "replace",
+        "patch"
+      ];
+      for (const method of methods) {
+        for (const middleware of middlewares) {
+          if (typeof middleware === "function") {
+            resource.useMiddleware(method, middleware);
+          }
+        }
+      }
+      return;
+    }
+    if (typeof middlewares === "object" && middlewares !== null) {
+      for (const [method, fns] of Object.entries(middlewares)) {
+        if (method === "*") {
+          const methods = resource._middlewareMethods || [
+            "get",
+            "list",
+            "listIds",
+            "getAll",
+            "count",
+            "page",
+            "insert",
+            "update",
+            "delete",
+            "deleteMany",
+            "exists",
+            "getMany",
+            "content",
+            "hasContent",
+            "query",
+            "getFromPartition",
+            "setContent",
+            "deleteContent",
+            "replace",
+            "patch"
+          ];
+          const middlewareArray = Array.isArray(fns) ? fns : [fns];
+          for (const targetMethod of methods) {
+            for (const middleware of middlewareArray) {
+              if (typeof middleware === "function") {
+                resource.useMiddleware(targetMethod, middleware);
+              }
+            }
+          }
+        } else {
+          const middlewareArray = Array.isArray(fns) ? fns : [fns];
+          for (const middleware of middlewareArray) {
+            if (typeof middleware === "function") {
+              resource.useMiddleware(method, middleware);
+            }
+          }
+        }
+      }
     }
-    return this.resources[name];
   }
   /**
    * List all resource names
@@ -22824,14 +21427,14 @@ class Database extends EventEmitter {
    * @returns {Resource} Resource instance
    */
   async getResource(name) {
-    if (!this.resources[name]) {
+    if (!this._resourcesMap[name]) {
       throw new ResourceNotFound({
         bucket: this.client.config.bucket,
         resourceName: name,
         id: name
       });
     }
-    return this.resources[name];
+    return this._resourcesMap[name];
   }
   /**
    * Get database configuration
@@ -22884,7 +21487,7 @@ class Database extends EventEmitter {
             }
           });
         }
-        Object.keys(this.resources).forEach((k) => delete this.resources[k]);
+        Object.keys(this.resources).forEach((k) => delete this._resourcesMap[k]);
       }
       if (this.client && typeof this.client.removeAllListeners === "function") {
         this.client.removeAllListeners();
@@ -24628,14 +23231,6 @@ class ReplicatorPlugin extends Plugin {
   }
   async start() {
   }
-  async stop() {
-    for (const replicator of this.replicators || []) {
-      if (replicator && typeof replicator.cleanup === "function") {
-        await replicator.cleanup();
-      }
-    }
-    this.removeDatabaseHooks();
-  }
   installDatabaseHooks() {
     this._afterCreateResourceHook = (resource) => {
       if (resource.name !== (this.config.replicatorLogResource || "plg_replicator_logs")) {
@@ -24965,20 +23560,20 @@ class ReplicatorPlugin extends Plugin {
     }
     this.emit("replicator.sync.completed", { replicatorId, stats: this.stats });
   }
-  async cleanup() {
+  async stop() {
     const [ok, error] = await tryFn(async () => {
       if (this.replicators && this.replicators.length > 0) {
         const cleanupPromises = this.replicators.map(async (replicator) => {
           const [replicatorOk, replicatorError] = await tryFn(async () => {
-            if (replicator && typeof replicator.cleanup === "function") {
-              await replicator.cleanup();
+            if (replicator && typeof replicator.stop === "function") {
+              await replicator.stop();
             }
           });
           if (!replicatorOk) {
             if (this.config.verbose) {
-              console.warn(`[ReplicatorPlugin] Failed to cleanup replicator ${replicator.name || replicator.id}: ${replicatorError.message}`);
+              console.warn(`[ReplicatorPlugin] Failed to stop replicator ${replicator.name || replicator.id}: ${replicatorError.message}`);
             }
-            this.emit("replicator_cleanup_error", {
+            this.emit("replicator_stop_error", {
               replicator: replicator.name || replicator.id || "unknown",
               driver: replicator.driver || "unknown",
               error: replicatorError.message
@@ -24987,6 +23582,7 @@ class ReplicatorPlugin extends Plugin {
         });
         await Promise.allSettled(cleanupPromises);
       }
+      this.removeDatabaseHooks();
       if (this.database && this.database.resources) {
         for (const resourceName of this.eventListenersInstalled) {
           const resource = this.database.resources[resourceName];
@@ -25006,9 +23602,9 @@ class ReplicatorPlugin extends Plugin {
     });
     if (!ok) {
       if (this.config.verbose) {
-        console.warn(`[ReplicatorPlugin] Failed to cleanup plugin: ${error.message}`);
+        console.warn(`[ReplicatorPlugin] Failed to stop plugin: ${error.message}`);
       }
-      this.emit("replicator_plugin_cleanup_error", {
+      this.emit("replicator_plugin_stop_error", {
         error: error.message
       });
     }
@@ -25828,7 +24424,7 @@ class SchedulerPlugin extends Plugin {
   }
   async _persistJobExecution(jobName, executionId, startTime, endTime, duration, status, result, error, retryCount) {
     const [ok, err] = await tryFn(
-      () => this.database.resource(this.config.jobHistoryResource).insert({
+      () => this.database.resources[this.config.jobHistoryResource].insert({
         id: executionId,
         jobName,
         status,
@@ -25969,7 +24565,7 @@ class SchedulerPlugin extends Plugin {
       queryParams.status = status;
     }
     const [ok, err, history] = await tryFn(
-      () => this.database.resource(this.config.jobHistoryResource).query(queryParams)
+      () => this.database.resources[this.config.jobHistoryResource].query(queryParams)
     );
     if (!ok) {
       if (this.config.verbose) {
@@ -26108,9 +24704,6 @@ class SchedulerPlugin extends Plugin {
     if (this._isTestEnvironment()) {
       this.activeJobs.clear();
     }
-  }
-  async cleanup() {
-    await this.stop();
     this.jobs.clear();
     this.statistics.clear();
     this.activeJobs.clear();
@@ -26359,7 +24952,7 @@ class StateMachinePlugin extends Plugin {
       let lastLogErr;
       for (let attempt = 0; attempt < this.config.retryAttempts; attempt++) {
         const [ok, err] = await tryFn(
-          () => this.database.resource(this.config.transitionLogResource).insert({
+          () => this.database.resources[this.config.transitionLogResource].insert({
             id: transitionId,
             machineId,
             entityId,
@@ -26395,11 +24988,11 @@ class StateMachinePlugin extends Plugin {
         updatedAt: now
       };
       const [updateOk] = await tryFn(
-        () => this.database.resource(this.config.stateResource).update(stateId, stateData)
+        () => this.database.resources[this.config.stateResource].update(stateId, stateData)
       );
       if (!updateOk) {
         const [insertOk, insertErr] = await tryFn(
-          () => this.database.resource(this.config.stateResource).insert({ id: stateId, ...stateData })
+          () => this.database.resources[this.config.stateResource].insert({ id: stateId, ...stateData })
         );
         if (!insertOk && this.config.verbose) {
           console.warn(`[StateMachinePlugin] Failed to upsert state:`, insertErr.message);
@@ -26462,7 +25055,7 @@ class StateMachinePlugin extends Plugin {
     if (this.config.persistTransitions) {
       const stateId = `${machineId}_${entityId}`;
       const [ok, err, stateRecord] = await tryFn(
-        () => this.database.resource(this.config.stateResource).get(stateId)
+        () => this.database.resources[this.config.stateResource].get(stateId)
       );
       if (ok && stateRecord) {
         machine.currentStates.set(entityId, stateRecord.currentState);
@@ -26505,7 +25098,7 @@ class StateMachinePlugin extends Plugin {
     }
     const { limit = 50, offset = 0 } = options;
     const [ok, err, transitions] = await tryFn(
-      () => this.database.resource(this.config.transitionLogResource).query({
+      () => this.database.resources[this.config.transitionLogResource].query({
         machineId,
         entityId
       }, {
@@ -26547,7 +25140,7 @@ class StateMachinePlugin extends Plugin {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const stateId = `${machineId}_${entityId}`;
       const [ok, err] = await tryFn(
-        () => this.database.resource(this.config.stateResource).insert({
+        () => this.database.resources[this.config.stateResource].insert({
           id: stateId,
           machineId,
           entityId,
@@ -26636,9 +25229,6 @@ class StateMachinePlugin extends Plugin {
   }
   async stop() {
     this.machines.clear();
-  }
-  async cleanup() {
-    await this.stop();
     this.removeAllListeners();
   }
 }
@@ -26653,7 +25243,7 @@ class TfStateError extends Error {
 }
 class InvalidStateFileError extends TfStateError {
   constructor(filePath, reason, context = {}) {
-    super(`Invalid Terraform state file "${filePath}": ${reason}`, context);
+    super(`Invalid Tfstate file "${filePath}": ${reason}`, context);
     this.name = "InvalidStateFileError";
     this.filePath = filePath;
     this.reason = reason;
@@ -26662,7 +25252,7 @@ class InvalidStateFileError extends TfStateError {
 class UnsupportedStateVersionError extends TfStateError {
   constructor(version, supportedVersions, context = {}) {
     super(
-      `Terraform state version ${version} is not supported. Supported versions: ${supportedVersions.join(", ")}`,
+      `Tfstate version ${version} is not supported. Supported versions: ${supportedVersions.join(", ")}`,
       context
     );
     this.name = "UnsupportedStateVersionError";
@@ -26672,7 +25262,7 @@ class UnsupportedStateVersionError extends TfStateError {
 }
 class StateFileNotFoundError extends TfStateError {
   constructor(filePath, context = {}) {
-    super(`Terraform state file not found: ${filePath}`, context);
+    super(`Tfstate file not found: ${filePath}`, context);
     this.name = "StateFileNotFoundError";
     this.filePath = filePath;
   }
@@ -34895,42 +33485,23 @@ class FilesystemTfStateDriver extends TfStateDriver {
 class TfStatePlugin extends Plugin {
   constructor(config = {}) {
     super(config);
-    const isNewFormat = config.driver !== void 0;
-    if (isNewFormat) {
-      this.driverType = config.driver || "s3";
-      this.driverConfig = config.config || {};
-      const resources = config.resources || {};
-      this.resourceName = resources.resources || "plg_tfstate_resources";
-      this.stateFilesName = resources.stateFiles || "plg_tfstate_state_files";
-      this.diffsName = resources.diffs || "plg_tfstate_state_diffs";
-      const monitor = config.monitor || {};
-      this.monitorEnabled = monitor.enabled || false;
-      this.monitorCron = monitor.cron || "*/5 * * * *";
-      const diffs = config.diffs || {};
-      this.trackDiffs = diffs.enabled !== void 0 ? diffs.enabled : true;
-      this.diffsLookback = diffs.lookback || 10;
-      this.asyncPartitions = config.asyncPartitions !== void 0 ? config.asyncPartitions : true;
-      this.autoSync = false;
-      this.watchPaths = [];
-      this.filters = config.filters || {};
-      this.verbose = config.verbose || false;
-    } else {
-      this.driverType = null;
-      this.driverConfig = {};
-      this.resourceName = config.resourceName || "plg_tfstate_resources";
-      this.stateFilesName = config.stateFilesName || "plg_tfstate_state_files";
-      this.diffsName = config.diffsName || config.stateHistoryName || "plg_tfstate_state_diffs";
-      this.stateHistoryName = this.diffsName;
-      this.autoSync = config.autoSync || false;
-      this.watchPaths = Array.isArray(config.watchPaths) ? config.watchPaths : [];
-      this.filters = config.filters || {};
-      this.trackDiffs = config.trackDiffs !== void 0 ? config.trackDiffs : true;
-      this.diffsLookback = 10;
-      this.asyncPartitions = config.asyncPartitions !== void 0 ? config.asyncPartitions : true;
-      this.verbose = config.verbose || false;
-      this.monitorEnabled = false;
-      this.monitorCron = "*/5 * * * *";
-    }
+    this.driverType = config.driver || null;
+    this.driverConfig = config.config || {};
+    const resources = config.resources || {};
+    this.resourceName = resources.resources || config.resourceName || "plg_tfstate_resources";
+    this.stateFilesName = resources.stateFiles || config.stateFilesName || "plg_tfstate_state_files";
+    this.diffsName = resources.diffs || config.diffsName || "plg_tfstate_state_diffs";
+    const monitor = config.monitor || {};
+    this.monitorEnabled = monitor.enabled || false;
+    this.monitorCron = monitor.cron || "*/5 * * * *";
+    const diffs = config.diffs || {};
+    this.trackDiffs = diffs.enabled !== void 0 ? diffs.enabled : config.trackDiffs !== void 0 ? config.trackDiffs : true;
+    this.diffsLookback = diffs.lookback || 10;
+    this.asyncPartitions = config.asyncPartitions !== void 0 ? config.asyncPartitions : true;
+    this.autoSync = config.autoSync || false;
+    this.watchPaths = config.watchPaths || [];
+    this.filters = config.filters || {};
+    this.verbose = config.verbose || false;
     this.supportedVersions = [3, 4];
     this.driver = null;
     this.resource = null;
@@ -34980,7 +33551,7 @@ class TfStatePlugin extends Plugin {
       name: this.lineagesName,
       attributes: {
         id: "string|required",
-        // = lineage UUID from Terraform state
+        // = lineage UUID from Tfstate
         latestSerial: "number",
         // Track latest for quick access
         latestStateId: "string",
@@ -35693,7 +34264,7 @@ class TfStatePlugin extends Plugin {
     return result;
   }
   /**
-   * Read and parse Terraform state file
+   * Read and parse Tfstate file
    * @private
    */
   async _readStateFile(filePath) {
@@ -35730,7 +34301,7 @@ class TfStatePlugin extends Plugin {
     }
   }
   /**
-   * Validate Terraform state version
+   * Validate Tfstate version
    * @private
    */
   _validateStateVersion(state) {
@@ -35743,7 +34314,7 @@ class TfStatePlugin extends Plugin {
     }
   }
   /**
-   * Extract resources from Terraform state
+   * Extract resources from Tfstate
    * @private
    */
   async _extractResources(state, filePath, stateFileId, lineageId) {
@@ -36310,14 +34881,14 @@ class TfStatePlugin extends Plugin {
     }
   }
   /**
-   * Export resources to Terraform state format
+   * Export resources to Tfstate format
    * @param {Object} options - Export options
    * @param {number} options.serial - Specific serial to export (default: latest)
    * @param {string[]} options.resourceTypes - Filter by resource types
    * @param {string} options.terraformVersion - Terraform version for output (default: '1.5.0')
    * @param {string} options.lineage - State lineage (default: auto-generated)
    * @param {Object} options.outputs - Terraform outputs to include
-   * @returns {Promise<Object>} Terraform state object
+   * @returns {Promise<Object>} Tfstate object
    *
    * @example
    * // Export latest state
@@ -37667,6 +36238,533 @@ class VectorPlugin extends Plugin {
   }
 }
 
+function mapFieldTypeToTypeScript(fieldType) {
+  const baseType = fieldType.split("|")[0].trim();
+  const typeMap = {
+    "string": "string",
+    "number": "number",
+    "integer": "number",
+    "boolean": "boolean",
+    "array": "any[]",
+    "object": "Record<string, any>",
+    "json": "Record<string, any>",
+    "secret": "string",
+    "email": "string",
+    "url": "string",
+    "date": "string",
+    // ISO date string
+    "datetime": "string",
+    // ISO datetime string
+    "ip4": "string",
+    "ip6": "string"
+  };
+  if (baseType.startsWith("embedding:")) {
+    const dimensions = parseInt(baseType.split(":")[1]);
+    return `number[] /* ${dimensions} dimensions */`;
+  }
+  return typeMap[baseType] || "any";
+}
+function isFieldRequired(fieldDef) {
+  if (typeof fieldDef === "string") {
+    return fieldDef.includes("|required");
+  }
+  if (typeof fieldDef === "object" && fieldDef.required) {
+    return true;
+  }
+  return false;
+}
+function generateResourceInterface(resourceName, attributes, timestamps = false) {
+  const interfaceName = toPascalCase(resourceName);
+  const lines = [];
+  lines.push(`export interface ${interfaceName} {`);
+  lines.push(`  /** Resource ID (auto-generated) */`);
+  lines.push(`  id: string;`);
+  lines.push("");
+  for (const [fieldName, fieldDef] of Object.entries(attributes)) {
+    const required = isFieldRequired(fieldDef);
+    const optional = required ? "" : "?";
+    let tsType;
+    if (typeof fieldDef === "string") {
+      tsType = mapFieldTypeToTypeScript(fieldDef);
+    } else if (typeof fieldDef === "object" && fieldDef.type) {
+      tsType = mapFieldTypeToTypeScript(fieldDef.type);
+      if (fieldDef.type === "object" && fieldDef.props) {
+        tsType = "{\n";
+        for (const [propName, propDef] of Object.entries(fieldDef.props)) {
+          const propType = typeof propDef === "string" ? mapFieldTypeToTypeScript(propDef) : mapFieldTypeToTypeScript(propDef.type);
+          const propRequired = isFieldRequired(propDef);
+          tsType += `    ${propName}${propRequired ? "" : "?"}: ${propType};
+`;
+        }
+        tsType += "  }";
+      }
+      if (fieldDef.type === "array" && fieldDef.items) {
+        const itemType = mapFieldTypeToTypeScript(fieldDef.items);
+        tsType = `Array<${itemType}>`;
+      }
+    } else {
+      tsType = "any";
+    }
+    if (fieldDef.description) {
+      lines.push(`  /** ${fieldDef.description} */`);
+    }
+    lines.push(`  ${fieldName}${optional}: ${tsType};`);
+  }
+  if (timestamps) {
+    lines.push("");
+    lines.push(`  /** Creation timestamp (ISO 8601) */`);
+    lines.push(`  createdAt: string;`);
+    lines.push(`  /** Last update timestamp (ISO 8601) */`);
+    lines.push(`  updatedAt: string;`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function toPascalCase(str) {
+  return str.split(/[_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+async function generateTypes(database, options = {}) {
+  const {
+    outputPath = "./types/database.d.ts",
+    moduleName = "s3db.js",
+    includeResource = true
+  } = options;
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * Auto-generated TypeScript definitions for s3db.js resources");
+  lines.push(" * Generated at: " + (/* @__PURE__ */ new Date()).toISOString());
+  lines.push(" * DO NOT EDIT - This file is auto-generated");
+  lines.push(" */");
+  lines.push("");
+  if (includeResource) {
+    lines.push(`import { Resource, Database } from '${moduleName}';`);
+    lines.push("");
+  }
+  const resourceInterfaces = [];
+  for (const [name, resource] of Object.entries(database.resources)) {
+    const attributes = resource.config?.attributes || resource.attributes || {};
+    const timestamps = resource.config?.timestamps || false;
+    const interfaceDef = generateResourceInterface(name, attributes, timestamps);
+    lines.push(interfaceDef);
+    resourceInterfaces.push({
+      name,
+      interfaceName: toPascalCase(name),
+      resource
+    });
+  }
+  lines.push("/**");
+  lines.push(" * Typed resource map for property access");
+  lines.push(" * @example");
+  lines.push(" * const users = db.resources.users; // Type-safe!");
+  lines.push(' * const user = await users.get("id"); // Autocomplete works!');
+  lines.push(" */");
+  lines.push("export interface ResourceMap {");
+  for (const { name, interfaceName } of resourceInterfaces) {
+    lines.push(`  /** ${interfaceName} resource */`);
+    if (includeResource) {
+      lines.push(`  ${name}: Resource<${interfaceName}>;`);
+    } else {
+      lines.push(`  ${name}: any;`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  if (includeResource) {
+    lines.push("/**");
+    lines.push(" * Extended Database class with typed resources");
+    lines.push(" */");
+    lines.push("declare module 's3db.js' {");
+    lines.push("  interface Database {");
+    lines.push("    resources: ResourceMap;");
+    lines.push("  }");
+    lines.push("");
+    lines.push("  interface Resource<T = any> {");
+    lines.push("    get(id: string): Promise<T>;");
+    lines.push("    getOrNull(id: string): Promise<T | null>;");
+    lines.push("    getOrThrow(id: string): Promise<T>;");
+    lines.push("    insert(data: Partial<T>): Promise<T>;");
+    lines.push("    update(id: string, data: Partial<T>): Promise<T>;");
+    lines.push("    patch(id: string, data: Partial<T>): Promise<T>;");
+    lines.push("    replace(id: string, data: Partial<T>): Promise<T>;");
+    lines.push("    delete(id: string): Promise<void>;");
+    lines.push("    list(options?: any): Promise<T[]>;");
+    lines.push("    query(filters: Partial<T>, options?: any): Promise<T[]>;");
+    lines.push("    validate(data: Partial<T>, options?: any): Promise<{ valid: boolean; errors: any[]; data: T | null }>;");
+    lines.push("  }");
+    lines.push("}");
+  }
+  const content = lines.join("\n");
+  if (outputPath) {
+    await promises.mkdir(path$1.dirname(outputPath), { recursive: true });
+    await promises.writeFile(outputPath, content, "utf-8");
+  }
+  return content;
+}
+async function printTypes(database, options = {}) {
+  const types = await generateTypes(database, { ...options, outputPath: null });
+  console.log(types);
+  return types;
+}
+
+class Factory {
+  /**
+   * Global sequence counter
+   * @private
+   */
+  static _sequences = /* @__PURE__ */ new Map();
+  /**
+   * Registered factories
+   * @private
+   */
+  static _factories = /* @__PURE__ */ new Map();
+  /**
+   * Database instance (set globally)
+   * @private
+   */
+  static _database = null;
+  /**
+   * Create a new factory definition
+   * @param {string} resourceName - Resource name
+   * @param {Object|Function} definition - Field definitions or function
+   * @param {Object} options - Factory options
+   * @returns {Factory} Factory instance
+   */
+  static define(resourceName, definition, options = {}) {
+    const factory = new Factory(resourceName, definition, options);
+    Factory._factories.set(resourceName, factory);
+    return factory;
+  }
+  /**
+   * Set global database instance
+   * @param {Database} database - s3db.js Database instance
+   */
+  static setDatabase(database) {
+    Factory._database = database;
+  }
+  /**
+   * Get factory by resource name
+   * @param {string} resourceName - Resource name
+   * @returns {Factory} Factory instance
+   */
+  static get(resourceName) {
+    return Factory._factories.get(resourceName);
+  }
+  /**
+   * Reset all sequences
+   */
+  static resetSequences() {
+    Factory._sequences.clear();
+  }
+  /**
+   * Reset all factories
+   */
+  static reset() {
+    Factory._sequences.clear();
+    Factory._factories.clear();
+    Factory._database = null;
+  }
+  /**
+   * Constructor
+   * @param {string} resourceName - Resource name
+   * @param {Object|Function} definition - Field definitions
+   * @param {Object} options - Factory options
+   */
+  constructor(resourceName, definition, options = {}) {
+    this.resourceName = resourceName;
+    this.definition = definition;
+    this.options = options;
+    this.traits = /* @__PURE__ */ new Map();
+    this.afterCreateCallbacks = [];
+    this.beforeCreateCallbacks = [];
+  }
+  /**
+   * Get next sequence number
+   * @param {string} name - Sequence name (default: factory name)
+   * @returns {number} Next sequence number
+   */
+  sequence(name = this.resourceName) {
+    const current = Factory._sequences.get(name) || 0;
+    const next = current + 1;
+    Factory._sequences.set(name, next);
+    return next;
+  }
+  /**
+   * Define a trait (state variation)
+   * @param {string} name - Trait name
+   * @param {Object|Function} attributes - Trait attributes
+   * @returns {Factory} This factory (for chaining)
+   */
+  trait(name, attributes) {
+    this.traits.set(name, attributes);
+    return this;
+  }
+  /**
+   * Register after create callback
+   * @param {Function} callback - Callback function
+   * @returns {Factory} This factory (for chaining)
+   */
+  afterCreate(callback) {
+    this.afterCreateCallbacks.push(callback);
+    return this;
+  }
+  /**
+   * Register before create callback
+   * @param {Function} callback - Callback function
+   * @returns {Factory} This factory (for chaining)
+   */
+  beforeCreate(callback) {
+    this.beforeCreateCallbacks.push(callback);
+    return this;
+  }
+  /**
+   * Build attributes without creating in database
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Build options
+   * @returns {Promise<Object>} Built attributes
+   */
+  async build(overrides = {}, options = {}) {
+    const { traits = [] } = options;
+    const seq = this.sequence();
+    let attributes = typeof this.definition === "function" ? await this.definition({ seq, factory: this }) : { ...this.definition };
+    for (const traitName of traits) {
+      const trait = this.traits.get(traitName);
+      if (!trait) {
+        throw new Error(`Trait '${traitName}' not found in factory '${this.resourceName}'`);
+      }
+      const traitAttrs = typeof trait === "function" ? await trait({ seq, factory: this }) : trait;
+      attributes = { ...attributes, ...traitAttrs };
+    }
+    attributes = { ...attributes, ...overrides };
+    for (const [key, value] of Object.entries(attributes)) {
+      if (typeof value === "function") {
+        attributes[key] = await value({ seq, factory: this });
+      }
+    }
+    return attributes;
+  }
+  /**
+   * Create resource in database
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Create options
+   * @returns {Promise<Object>} Created resource
+   */
+  async create(overrides = {}, options = {}) {
+    const { database = Factory._database } = options;
+    if (!database) {
+      throw new Error("Database not set. Use Factory.setDatabase(db) or pass database option");
+    }
+    let attributes = await this.build(overrides, options);
+    for (const callback of this.beforeCreateCallbacks) {
+      attributes = await callback(attributes) || attributes;
+    }
+    const resource = database.resources[this.resourceName];
+    if (!resource) {
+      throw new Error(`Resource '${this.resourceName}' not found in database`);
+    }
+    let created = await resource.insert(attributes);
+    for (const callback of this.afterCreateCallbacks) {
+      created = await callback(created, { database }) || created;
+    }
+    return created;
+  }
+  /**
+   * Create multiple resources
+   * @param {number} count - Number of resources to create
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Create options
+   * @returns {Promise<Object[]>} Created resources
+   */
+  async createMany(count, overrides = {}, options = {}) {
+    const resources = [];
+    for (let i = 0; i < count; i++) {
+      const resource = await this.create(overrides, options);
+      resources.push(resource);
+    }
+    return resources;
+  }
+  /**
+   * Build multiple resources without creating
+   * @param {number} count - Number of resources to build
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Build options
+   * @returns {Promise<Object[]>} Built resources
+   */
+  async buildMany(count, overrides = {}, options = {}) {
+    const resources = [];
+    for (let i = 0; i < count; i++) {
+      const resource = await this.build(overrides, options);
+      resources.push(resource);
+    }
+    return resources;
+  }
+  /**
+   * Create with specific traits
+   * @param {string|string[]} traits - Trait name(s)
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Create options
+   * @returns {Promise<Object>} Created resource
+   */
+  async createWithTraits(traits, overrides = {}, options = {}) {
+    const traitArray = Array.isArray(traits) ? traits : [traits];
+    return this.create(overrides, { ...options, traits: traitArray });
+  }
+  /**
+   * Build with specific traits
+   * @param {string|string[]} traits - Trait name(s)
+   * @param {Object} overrides - Override attributes
+   * @param {Object} options - Build options
+   * @returns {Promise<Object>} Built resource
+   */
+  async buildWithTraits(traits, overrides = {}, options = {}) {
+    const traitArray = Array.isArray(traits) ? traits : [traits];
+    return this.build(overrides, { ...options, traits: traitArray });
+  }
+}
+
+class Seeder {
+  /**
+   * Constructor
+   * @param {Database} database - s3db.js Database instance
+   * @param {Object} options - Seeder options
+   */
+  constructor(database, options = {}) {
+    this.database = database;
+    this.options = options;
+    this.verbose = options.verbose !== false;
+  }
+  /**
+   * Log message (if verbose)
+   * @param {string} message - Message to log
+   * @private
+   */
+  log(message) {
+    if (this.verbose) {
+      console.log(`[Seeder] ${message}`);
+    }
+  }
+  /**
+   * Seed resources using factories
+   * @param {Object} specs - Seed specifications { resourceName: count }
+   * @returns {Promise<Object>} Created resources by resource name
+   *
+   * @example
+   * const created = await seeder.seed({
+   *   users: 10,
+   *   posts: 50
+   * });
+   */
+  async seed(specs) {
+    const created = {};
+    for (const [resourceName, count] of Object.entries(specs)) {
+      this.log(`Seeding ${count} ${resourceName}...`);
+      const factory = Factory.get(resourceName);
+      if (!factory) {
+        throw new Error(`Factory for '${resourceName}' not found. Define it with Factory.define()`);
+      }
+      created[resourceName] = await factory.createMany(count, {}, { database: this.database });
+      this.log(`\u2705 Created ${count} ${resourceName}`);
+    }
+    return created;
+  }
+  /**
+   * Seed with custom callback
+   * @param {Function} callback - Seeding callback
+   * @returns {Promise<any>} Result of callback
+   *
+   * @example
+   * await seeder.call(async (db) => {
+   *   const user = await UserFactory.create();
+   *   const posts = await PostFactory.createMany(5, { userId: user.id });
+   *   return { user, posts };
+   * });
+   */
+  async call(callback) {
+    this.log("Running custom seeder...");
+    const result = await callback(this.database);
+    this.log("\u2705 Custom seeder completed");
+    return result;
+  }
+  /**
+   * Truncate resources (delete all data)
+   * @param {string[]} resourceNames - Resource names to truncate
+   * @returns {Promise<void>}
+   *
+   * @example
+   * await seeder.truncate(['users', 'posts']);
+   */
+  async truncate(resourceNames) {
+    for (const resourceName of resourceNames) {
+      this.log(`Truncating ${resourceName}...`);
+      const resource = this.database.resources[resourceName];
+      if (!resource) {
+        this.log(`\u26A0\uFE0F  Resource '${resourceName}' not found, skipping`);
+        continue;
+      }
+      const ids = await resource.listIds();
+      if (ids.length > 0) {
+        await resource.deleteMany(ids);
+        this.log(`\u2705 Deleted ${ids.length} ${resourceName}`);
+      } else {
+        this.log(`\u2705 ${resourceName} already empty`);
+      }
+    }
+  }
+  /**
+   * Truncate all resources
+   * @returns {Promise<void>}
+   */
+  async truncateAll() {
+    const resourceNames = Object.keys(this.database.resources);
+    await this.truncate(resourceNames);
+  }
+  /**
+   * Run multiple seeders in order
+   * @param {Function[]} seeders - Array of seeder functions
+   * @returns {Promise<Object[]>} Results of each seeder
+   *
+   * @example
+   * await seeder.run([
+   *   async (db) => await UserFactory.createMany(10),
+   *   async (db) => await PostFactory.createMany(50)
+   * ]);
+   */
+  async run(seeders) {
+    const results = [];
+    for (const seederFn of seeders) {
+      this.log(`Running seeder ${seederFn.name || "anonymous"}...`);
+      const result = await seederFn(this.database);
+      results.push(result);
+      this.log(`\u2705 Completed ${seederFn.name || "anonymous"}`);
+    }
+    return results;
+  }
+  /**
+   * Seed and return specific resources
+   * @param {Object} specs - Seed specifications
+   * @returns {Promise<Object>} Created resources
+   *
+   * @example
+   * const { users, posts } = await seeder.seedAndReturn({
+   *   users: 5,
+   *   posts: 10
+   * });
+   */
+  async seedAndReturn(specs) {
+    return await this.seed(specs);
+  }
+  /**
+   * Reset database (truncate all and reset sequences)
+   * @returns {Promise<void>}
+   */
+  async reset() {
+    this.log("Resetting database...");
+    await this.truncateAll();
+    Factory.resetSequences();
+    this.log("\u2705 Database reset complete");
+  }
+}
+
 function sanitizeLabel(value) {
   if (typeof value !== "string") {
     value = String(value);
@@ -38068,6 +37166,7 @@ exports.DynamoDBReplicator = DynamoDBReplicator;
 exports.EncryptionError = EncryptionError;
 exports.ErrorMap = ErrorMap;
 exports.EventualConsistencyPlugin = EventualConsistencyPlugin;
+exports.Factory = Factory;
 exports.FilesystemBackupDriver = FilesystemBackupDriver;
 exports.FilesystemCache = FilesystemCache;
 exports.FullTextPlugin = FullTextPlugin;
@@ -38113,6 +37212,7 @@ exports.S3dbReplicator = S3dbReplicator;
 exports.SchedulerPlugin = SchedulerPlugin;
 exports.Schema = Schema;
 exports.SchemaError = SchemaError;
+exports.Seeder = Seeder;
 exports.SqsConsumer = SqsConsumer;
 exports.SqsReplicator = SqsReplicator;
 exports.StateMachinePlugin = StateMachinePlugin;
@@ -38131,8 +37231,6 @@ exports.calculateEffectiveLimit = calculateEffectiveLimit;
 exports.calculateSystemOverhead = calculateSystemOverhead;
 exports.calculateTotalSize = calculateTotalSize;
 exports.calculateUTF8Bytes = calculateUTF8Bytes;
-exports.clearUTF8Cache = clearUTF8Cache;
-exports.clearUTF8Memo = clearUTF8Memo;
 exports.clearUTF8Memory = clearUTF8Memory;
 exports.createBackupDriver = createBackupDriver;
 exports.createConsumer = createConsumer;
@@ -38148,12 +37246,14 @@ exports.encodeDecimal = encodeDecimal;
 exports.encodeFixedPoint = encodeFixedPoint;
 exports.encodeFixedPointBatch = encodeFixedPointBatch;
 exports.encrypt = encrypt;
+exports.generateTypes = generateTypes;
 exports.getBehavior = getBehavior;
 exports.getSizeBreakdown = getSizeBreakdown;
 exports.idGenerator = idGenerator;
 exports.mapAwsError = mapAwsError;
 exports.md5 = md5;
 exports.passwordGenerator = passwordGenerator;
+exports.printTypes = printTypes;
 exports.sha256 = sha256;
 exports.streamToString = streamToString;
 exports.transformValue = transformValue;