s3db.js 12.1.0 → 12.2.1

package/dist/s3db.es.js

@@ -1,13 +1,10 @@
 import crypto$1, { createHash } from 'crypto';
 import { customAlphabet, urlAlphabet } from 'nanoid';
 import EventEmitter from 'events';
-import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
-import { swaggerUI } from '@hono/swagger-ui';
 import { mkdir, copyFile, unlink, stat, access, readdir, writeFile, readFile, rm, watch } from 'fs/promises';
 import fs, { createReadStream, createWriteStream, realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$2, lstatSync, existsSync } from 'fs';
 import { pipeline } from 'stream/promises';
-import path$1, { join } from 'path';
+import path$1, { join, dirname } from 'path';
 import { Transform, Writable } from 'stream';
 import zlib from 'node:zlib';
 import os from 'os';
@@ -209,8 +206,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)) {
@@ -1604,18 +1599,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;
 }
 
@@ -1702,11 +1685,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
@@ -2454,1800 +2448,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();
-  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();
-    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({
-          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 = 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"
       }
     }
   }
@@ -4333,21 +2627,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 };
 }
@@ -4364,7 +2692,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
@@ -4681,6 +3008,11 @@ class ApiPlugin extends Plugin {
     if (this.config.verbose) {
       console.log("[API Plugin] Starting server...");
     }
+    const serverPath = "./server.js";
+    const { ApiServer } = await import(
+      /* @vite-ignore */
+      serverPath
+    );
     this.server = new ApiServer({
       port: this.config.port,
       host: this.config.host,
@@ -5743,8 +4075,6 @@ class MultiBackupDriver extends BaseBackupDriver {
       strategy: "all",
       // 'all', 'any', 'priority'
       concurrency: 3,
-      requireAll: true,
-      // For backward compatibility
       ...config
     });
     this.drivers = [];
@@ -6381,13 +4711,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) {
@@ -6422,7 +4752,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"] }
@@ -6730,7 +5060,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 }
         })
@@ -6758,14 +5088,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 }
         })
@@ -6832,7 +5162,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}`);
           }
@@ -6868,12 +5198,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 {
@@ -9769,9 +8093,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)
         );
@@ -11095,8 +9416,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",
@@ -13430,7 +11750,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`);
@@ -13541,7 +11861,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);
@@ -13592,7 +11912,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,
@@ -13631,7 +11951,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,
@@ -13677,7 +11997,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,
@@ -13727,14 +12047,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,
@@ -13918,7 +12238,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,
@@ -13926,7 +12246,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;
@@ -13977,7 +12297,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);
@@ -14045,7 +12365,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;
     }
@@ -19330,12 +17650,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;
@@ -19398,19 +17748,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;
@@ -19537,19 +17874,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 : cloneDeep(data);
+    if (!includeId && dataToValidate.id) {
+      delete dataToValidate.id;
+    }
     const result = {
       original: 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;
   }
   /**
@@ -19814,12 +18203,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]
@@ -19830,7 +18219,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({
@@ -19934,6 +18323,7 @@ ${errorDetails}`,
   async get(id) {
     if (isObject(id)) throw new Error(`id cannot be an object`);
     if (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) {
@@ -19982,17 +18372,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;
   }
   /**
@@ -20048,7 +18488,7 @@ ${errorDetails}`,
     }
     const preProcessedData = await this.executeHooks("beforeUpdate", cloneDeep(mergedData));
     const completeData = { ...originalData, ...preProcessedData, id };
-    const { isValid, errors, data } = await this.validate(cloneDeep(completeData));
+    const { isValid, errors, data } = await this.validate(cloneDeep(completeData), { includeId: true });
     if (!isValid) {
       throw new InvalidResourceItem({
         bucket: this.client.config.bucket,
@@ -20221,12 +18661,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
@@ -20326,6 +18771,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 = cloneDeep(fullData);
     const attributesWithDefaults = this.applyDefaults(dataClone);
@@ -20340,7 +18786,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({
@@ -20413,7 +18859,8 @@ ${errorDetails}`,
         await this.handlePartitionReferenceUpdates({}, replacedObject);
       }
     }
-    return replacedObject;
+    const finalResult = await this.executeHooks("afterReplace", replacedObject);
+    return finalResult;
   }
   /**
    * Update with conditional check (If-Match ETag)
@@ -20471,7 +18918,7 @@ ${errorDetails}`,
     }
     const preProcessedData = await this.executeHooks("beforeUpdate", cloneDeep(mergedData));
     const completeData = { ...originalData, ...preProcessedData, id };
-    const { isValid, errors, data } = await this.validate(cloneDeep(completeData));
+    const { isValid, errors, data } = await this.validate(cloneDeep(completeData), { includeId: true });
     if (!isValid) {
       return {
         success: false,
@@ -20692,6 +19139,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];
@@ -20716,6 +19164,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;
   }
@@ -20751,6 +19200,7 @@ ${errorDetails}`,
    * const results = await resource.deleteMany(deletedIds);
       */
   async deleteMany(ids) {
+    await this.executeHooks("beforeDeleteMany", { ids });
     const packages = chunk(
       ids.map((id) => this.getResourceKey(id)),
       1e3
@@ -20772,6 +19222,7 @@ ${errorDetails}`,
       });
       return response;
     });
+    await this.executeHooks("afterDeleteMany", { ids, results });
     this.emit("deleteMany", ids.length);
     return results;
   }
@@ -20893,6 +19344,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 });
@@ -20902,7 +19354,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 }));
@@ -21045,6 +19498,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.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));
@@ -21065,8 +19519,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)
@@ -21313,21 +19768,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;
   }
   /**
@@ -21423,6 +19863,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 });
     }
@@ -21450,7 +19891,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
@@ -21530,7 +19972,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) {
@@ -21916,7 +20358,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(", ")}`);
@@ -21964,17 +20431,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;
@@ -22080,7 +20565,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,
@@ -22149,7 +20634,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({
@@ -22661,7 +21146,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
@@ -22669,14 +21154,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,
@@ -22686,8 +21170,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 {
@@ -22715,12 +21198,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;
@@ -22738,6 +21258,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";
@@ -22761,7 +21284,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,
@@ -22777,16 +21300,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
@@ -22801,14 +21404,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
@@ -22861,7 +21464,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();
@@ -24605,14 +23208,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")) {
@@ -24942,20 +23537,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
@@ -24964,6 +23559,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];
@@ -24983,9 +23579,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
       });
     }
@@ -25805,7 +24401,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,
@@ -25946,7 +24542,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) {
@@ -26085,9 +24681,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();
@@ -26336,7 +24929,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,
@@ -26372,11 +24965,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);
@@ -26439,7 +25032,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);
@@ -26482,7 +25075,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
       }, {
@@ -26524,7 +25117,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,
@@ -26613,9 +25206,6 @@ class StateMachinePlugin extends Plugin {
   }
   async stop() {
     this.machines.clear();
-  }
-  async cleanup() {
-    await this.stop();
     this.removeAllListeners();
   }
 }
@@ -26630,7 +25220,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;
@@ -26639,7 +25229,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";
@@ -26649,7 +25239,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;
   }
@@ -34872,42 +33462,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;
@@ -34957,7 +33528,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",
@@ -35670,7 +34241,7 @@ class TfStatePlugin extends Plugin {
     return result;
   }
   /**
-   * Read and parse Terraform state file
+   * Read and parse Tfstate file
    * @private
    */
   async _readStateFile(filePath) {
@@ -35707,7 +34278,7 @@ class TfStatePlugin extends Plugin {
     }
   }
   /**
-   * Validate Terraform state version
+   * Validate Tfstate version
    * @private
    */
   _validateStateVersion(state) {
@@ -35720,7 +34291,7 @@ class TfStatePlugin extends Plugin {
     }
   }
   /**
-   * Extract resources from Terraform state
+   * Extract resources from Tfstate
    * @private
    */
   async _extractResources(state, filePath, stateFileId, lineageId) {
@@ -36287,14 +34858,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
@@ -37644,6 +36215,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 mkdir(dirname(outputPath), { recursive: true });
+    await 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);
@@ -38018,5 +37116,5 @@ var metrics = /*#__PURE__*/Object.freeze({
   silhouetteScore: silhouetteScore
 });
 
-export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, InvalidResourceItem, MemoryCache, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Cache, clearUTF8Memo, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
+export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, Factory, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, InvalidResourceItem, MemoryCache, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, Seeder, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, generateTypes, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, printTypes, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
 //# sourceMappingURL=s3db.es.js.map