s3db.js 6.2.0 → 7.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s3db.js",
-  "version": "6.2.0",
+  "version": "7.0.0",
   "description": "Use AWS S3, the world's most reliable document storage, as a database with this ORM.",
   "main": "dist/s3db.cjs.js",
   "module": "dist/s3db.es.js",
@@ -8,19 +8,7 @@
   "types": "dist/s3db.d.ts",
   "unpkg": "dist/s3db.iife.min.js",
   "jsdelivr": "dist/s3db.iife.min.js",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/s3db.es.js",
-      "require": "./dist/s3db.cjs.js",
-      "browser": "./dist/s3db.iife.js",
-      "default": "./dist/s3db.es.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "author": "forattini-dev",
+  "author": "@stone/martech",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -35,68 +23,55 @@
     "aws",
     "database"
   ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/s3db.es.js",
+      "require": "./dist/s3db.cjs.js",
+      "types": "./dist/s3db.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "PLUGINS.md",
+    "UNLICENSE"
+  ],
+  "peerDependencies": {},
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.842.0",
+    "@aws-sdk/client-s3": "^3.691.0",
     "@supercharge/promise-pool": "^3.2.0",
-    "avsc": "^5.7.8",
-    "fastest-validator": "^1.19.1",
-    "flat": "^6.0.1",
-    "json-stable-stringify": "^1.3.0",
+    "fastest-validator": "^1.19.0",
+    "hash-wasm": "^4.14.0",
+    "json-stable-stringify": "^1.1.1",
     "lodash-es": "^4.17.21",
-    "nanoid": "5.1.5",
-    "zlib": "^1.0.5"
-  },
-  "peerDependencies": {
-    "@aws-sdk/client-sqs": "^3.0.0",
-    "@google-cloud/bigquery": "^7.0.0",
-    "pg": "^8.0.0",
-    "uuid": "^9.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@aws-sdk/client-sqs": {
-      "optional": true
-    },
-    "@google-cloud/bigquery": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    },
-    "uuid": {
-      "optional": true
-    }
+    "nanoid": "^5.0.9"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.28.0",
-    "@jest/globals": "^30.0.4",
-    "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^28.0.6",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-terser": "^0.4.4",
-    "babel-jest": "^30.0.4",
-    "cliui": "^9.0.1",
-    "coveralls": "^3.1.1",
-    "dotenv": "^17.0.1",
-    "esbuild": "^0.25.6",
-    "fakerator": "^0.3.6",
-    "jest": "^30.0.4",
-    "multi-progress": "^4.0.0",
-    "progress": "^2.0.3",
-    "rollup": "^4.44.2",
-    "rollup-plugin-esbuild": "^6.2.1",
-    "rollup-plugin-polyfill-node": "^0.13.0",
-    "uuid": "^11.1.0"
+    "@rollup/plugin-replace": "^6.0.1",
+    "@types/node": "24.0.14",
+    "jest": "^29.7.0",
+    "rollup": "^4.27.4",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "typescript": "5.8.3"
   },
+  "funding": [
+    "https://github.com/sponsors/forattini-dev"
+  ],
   "scripts": {
     "build": "rollup -c",
-    "clean-build": "node scripts/clean-build.js",
-    "verify": "node scripts/verify-build.js",
-    "test-builds": "node examples/test-builds.js",
-    "coverage": "coveralls < coverage/lcov.info",
-    "coverage:serve": "npx http-server ./coverage/lcov-report",
-    "test": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "test:full": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --detectOpenHandles",
-    "test:watch": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --watch --detectOpenHandles"
+    "dev": "rollup -c -w",
+    "test": "npm run test:js && npm run test:ts",
+    "test:js": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:ts": "tsc --noEmit --project tests/typescript/tsconfig.json",
+    "test:js-converage": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --detectOpenHandles --coverage",
+    "test:js-ai": "node --no-warnings --experimental-vm-modules node_modules/jest/bin/jest.js --detectOpenHandles --runInBand",
+    "test:types": "tsc --noEmit --project tests/typescript/tsconfig.json",
+    "test:types:basic": "tsc --noEmit tests/typescript/basic-usage.test.ts",
+    "test:types:direct": "tsc --noEmit tests/typescript/direct-type-test.ts",
+    "test:types:watch": "tsc --noEmit --watch --project tests/typescript/tsconfig.json",
+    "validate:types": "npm run test:types && echo 'TypeScript definitions are valid!'"
   }
 }

package/src/behaviors/body-only.js

@@ -0,0 +1,110 @@
+import { calculateTotalSize } from '../concerns/calculator.js';
+import { tryFn, tryFnSync } from '../concerns/try-fn.js';
+
+/**
+ * Body Only Behavior Configuration Documentation
+ *
+ * The `body-only` behavior stores all data in the S3 object body as JSON, keeping only
+ * the version field (`_v`) in metadata. This allows for unlimited data size since S3
+ * objects can be up to 5TB, but requires reading the full object body for any operation.
+ *
+ * ## Purpose & Use Cases
+ * - For large objects that exceed S3 metadata limits
+ * - When you need to store complex nested data structures
+ * - For objects that will be read infrequently (higher latency)
+ * - When you want to avoid metadata size constraints entirely
+ *
+ * ## How It Works
+ * - Keeps only the `_v` (version) field in S3 metadata
+ * - Serializes all other data as JSON in the object body
+ * - Requires full object read for any data access
+ * - No size limits on data (only S3 object size limit of 5TB)
+ *
+ * ## Performance Considerations
+ * - Higher latency for read operations (requires full object download)
+ * - Higher bandwidth usage for read operations
+ * - No metadata-based filtering or querying possible
+ * - Best for large, infrequently accessed data
+ *
+ * @example
+ * // Create a resource with body-only behavior
+ * const resource = await db.createResource({
+ *   name: 'large_documents',
+ *   attributes: { ... },
+ *   behavior: 'body-only'
+ * });
+ *
+ * // All data goes to body, only _v stays in metadata
+ * const doc = await resource.insert({
+ *   title: 'Large Document',
+ *   content: 'Very long content...',
+ *   metadata: { ... }
+ * });
+ *
+ * ## Comparison to Other Behaviors
+ * | Behavior         | Metadata Usage | Body Usage | Size Limits | Performance |
+ * |------------------|----------------|------------|-------------|-------------|
+ * | body-only        | Minimal (_v)   | All data   | 5TB         | Slower reads |
+ * | body-overflow    | Optimized      | Overflow   | 2KB metadata | Balanced     |
+ * | truncate-data    | All (truncated)| None       | 2KB metadata | Fast reads   |
+ * | enforce-limits   | All (limited)  | None       | 2KB metadata | Fast reads   |
+ * | user-managed     | All (unlimited)| None       | S3 limit    | Fast reads   |
+ *
+ * @typedef {Object} BodyOnlyBehaviorConfig
+ * @property {boolean} [enabled=true] - Whether the behavior is active
+ */
+export async function handleInsert({ resource, data, mappedData }) {
+  // Keep only the version field in metadata
+  const metadataOnly = {
+    '_v': mappedData._v || String(resource.version)
+  };
+  metadataOnly._map = JSON.stringify(resource.schema.map);
+  
+  // Use o objeto original para o body
+  const body = JSON.stringify(mappedData);
+  
+  return { mappedData: metadataOnly, body };
+}
+
+export async function handleUpdate({ resource, id, data, mappedData }) {
+  // For updates, we need to merge with existing data
+  // Since we can't easily read the existing body during update,
+  // we'll put the update data in the body and let the resource handle merging
+  
+  // Keep only the version field in metadata
+  const metadataOnly = {
+    '_v': mappedData._v || String(resource.version)
+  };
+  metadataOnly._map = JSON.stringify(resource.schema.map);
+  
+  // Use o objeto original para o body
+  const body = JSON.stringify(mappedData);
+  
+  return { mappedData: metadataOnly, body };
+}
+
+export async function handleUpsert({ resource, id, data, mappedData }) {
+  // Same as insert for body-only behavior
+  return handleInsert({ resource, data, mappedData });
+}
+
+export async function handleGet({ resource, metadata, body }) {
+  // Parse the body to get the actual data
+  let bodyData = {};
+  if (body && body.trim() !== '') {
+    const [ok, err, parsed] = tryFnSync(() => JSON.parse(body));
+    if (ok) {
+      bodyData = parsed;
+    } else {
+      bodyData = {};
+    }
+  }
+  
+  // Merge metadata (which contains _v) with body data
+  const mergedData = {
+    ...bodyData,
+    ...metadata // metadata contains _v
+  };
+  
+  return { metadata: mergedData, body };
+}

package/src/behaviors/body-overflow.js

@@ -0,0 +1,153 @@
+import { calculateTotalSize, calculateAttributeSizes, calculateUTF8Bytes } from '../concerns/calculator.js';
+import { calculateEffectiveLimit } from '../concerns/calculator.js';
+import { S3_METADATA_LIMIT_BYTES } from './enforce-limits.js';
+import { tryFn, tryFnSync } from '../concerns/try-fn.js';
+
+const OVERFLOW_FLAG = '$overflow';
+const OVERFLOW_FLAG_VALUE = 'true';
+const OVERFLOW_FLAG_BYTES = calculateUTF8Bytes(OVERFLOW_FLAG) + calculateUTF8Bytes(OVERFLOW_FLAG_VALUE);
+
+/**
+ * Body Overflow Behavior Configuration Documentation
+ *
+ * The `body-overflow` behavior optimizes metadata usage by sorting attributes by size
+ * in ascending order and placing as many small attributes as possible in metadata,
+ * while moving larger attributes to the S3 object body. This maximizes metadata
+ * utilization while keeping frequently accessed small fields in metadata for fast access.
+ *
+ * ## Purpose & Use Cases
+ * - For objects with mixed field sizes (some small, some large)
+ * - When you want to optimize for both metadata efficiency and read performance
+ * - For objects that exceed metadata limits but have important small fields
+ * - When you need fast access to frequently used small fields
+ *
+ * ## How It Works
+ * 1. Calculates the size of each attribute
+ * 2. Sorts attributes by size in ascending order (smallest first)
+ * 3. Fills metadata with small attributes until limit is reached
+ * 4. Places remaining (larger) attributes in the object body as JSON
+ * 5. Adds a `$overflow` flag to metadata to indicate body usage
+ *
+ * ## Performance Characteristics
+ * - Fast access to small fields (in metadata)
+ * - Slower access to large fields (requires body read)
+ * - Optimized metadata utilization
+ * - Balanced approach between performance and size efficiency
+ *
+ * @example
+ * // Create a resource with body-overflow behavior
+ * const resource = await db.createResource({
+ *   name: 'mixed_content',
+ *   attributes: { ... },
+ *   behavior: 'body-overflow'
+ * });
+ *
+ * // Small fields go to metadata, large fields go to body
+ * const doc = await resource.insert({
+ *   id: 'doc123',           // Small -> metadata
+ *   title: 'Short Title',   // Small -> metadata
+ *   content: 'Very long...', // Large -> body
+ *   metadata: { ... }       // Large -> body
+ * });
+ *
+ * ## Comparison to Other Behaviors
+ * | Behavior         | Metadata Usage | Body Usage | Size Limits | Performance |
+ * |------------------|----------------|------------|-------------|-------------|
+ * | body-overflow    | Optimized      | Overflow   | 2KB metadata | Balanced     |
+ * | body-only        | Minimal (_v)   | All data   | 5TB         | Slower reads |
+ * | truncate-data    | All (truncated)| None       | 2KB metadata | Fast reads   |
+ * | enforce-limits   | All (limited)  | None       | 2KB metadata | Fast reads   |
+ * | user-managed     | All (unlimited)| None       | S3 limit    | Fast reads   |
+ *
+ * @typedef {Object} BodyOverflowBehaviorConfig
+ * @property {boolean} [enabled=true] - Whether the behavior is active
+ * @property {number} [metadataReserve=50] - Reserve bytes for system fields
+ * @property {string[]} [priorityFields] - Fields that should be prioritized in metadata
+ * @property {boolean} [preserveOrder=false] - Whether to preserve original field order
+ */
+export async function handleInsert({ resource, data, mappedData, originalData }) {
+  const effectiveLimit = calculateEffectiveLimit({
+    s3Limit: S3_METADATA_LIMIT_BYTES,
+    systemConfig: {
+      version: resource.version,
+      timestamps: resource.config.timestamps,
+      id: data.id
+    }
+  });
+
+  const attributeSizes = calculateAttributeSizes(mappedData);
+  const sortedFields = Object.entries(attributeSizes)
+    .sort(([, a], [, b]) => a - b);
+
+  const metadataFields = {};
+  const bodyFields = {};
+  let currentSize = 0;
+  let willOverflow = false;
+
+  // Always include version field first
+  if (mappedData._v) {
+    metadataFields._v = mappedData._v;
+    currentSize += attributeSizes._v;
+  }
+
+  // Reserve space for $overflow if overflow is possible
+  let reservedLimit = effectiveLimit;
+  for (const [fieldName, size] of sortedFields) {
+    if (fieldName === '_v') continue;
+    if (!willOverflow && (currentSize + size > effectiveLimit)) {
+      reservedLimit -= OVERFLOW_FLAG_BYTES;
+      willOverflow = true;
+    }
+    if (!willOverflow && (currentSize + size <= reservedLimit)) {
+      metadataFields[fieldName] = mappedData[fieldName];
+      currentSize += size;
+    } else {
+      bodyFields[fieldName] = mappedData[fieldName];
+      willOverflow = true;
+    }
+  }
+
+  if (willOverflow) {
+    metadataFields[OVERFLOW_FLAG] = OVERFLOW_FLAG_VALUE;
+  }
+
+  const hasOverflow = Object.keys(bodyFields).length > 0;
+  let body = hasOverflow ? JSON.stringify(bodyFields) : "";
+  if (!hasOverflow) body = '{}';
+
+  // FIX: Only return metadataFields as mappedData, not full mappedData
+  return { mappedData: metadataFields, body };
+}
+
+export async function handleUpdate({ resource, id, data, mappedData, originalData }) {
+  // For updates, use the same logic as insert (split fields by size)
+  return handleInsert({ resource, data, mappedData, originalData });
+}
+
+export async function handleUpsert({ resource, id, data, mappedData }) {
+  return handleInsert({ resource, data, mappedData });
+}
+
+export async function handleGet({ resource, metadata, body }) {
+  // Parse body content if it exists
+  let bodyData = {};
+  if (body && body.trim() !== '') {
+    const [ok, err, parsed] = tryFnSync(() => JSON.parse(body));
+    if (ok) {
+      bodyData = parsed;
+    } else {
+      bodyData = {};
+    }
+  }
+
+  // Merge metadata and body data, with metadata taking precedence
+  const mergedData = {
+    ...bodyData,
+    ...metadata
+  };
+
+  // Remove internal flags from the merged result
+  delete mergedData.$overflow;
+
+  return { metadata: mergedData, body };
+}

package/src/behaviors/enforce-limits.js

@@ -0,0 +1,195 @@
+import { calculateTotalSize } from '../concerns/calculator.js';
+import { calculateEffectiveLimit } from '../concerns/calculator.js';
+
+export const S3_METADATA_LIMIT_BYTES = 2047;
+
+/**
+ * Enforce Limits Behavior Configuration Documentation
+ * 
+ * This behavior enforces various limits on data operations to prevent abuse and ensure
+ * system stability. It can limit body size, metadata size, and other resource constraints.
+ * 
+ * @typedef {Object} EnforceLimitsBehaviorConfig
+ * @property {boolean} [enabled=true] - Whether the behavior is active
+ * @property {number} [maxBodySize=1024*1024] - Maximum body size in bytes (1MB default)
+ * @property {number} [maxMetadataSize=2048] - Maximum metadata size in bytes (2KB default)
+ * @property {number} [maxKeySize=1024] - Maximum key size in bytes (1KB default)
+ * @property {number} [maxValueSize=1024*1024] - Maximum value size in bytes (1MB default)
+ * @property {number} [maxFields=100] - Maximum number of fields in a single object
+ * @property {number} [maxNestingDepth=10] - Maximum nesting depth for objects and arrays
+ * @property {number} [maxArrayLength=1000] - Maximum length for arrays
+ * @property {number} [maxStringLength=10000] - Maximum length for string values
+ * @property {number} [maxNumberValue=Number.MAX_SAFE_INTEGER] - Maximum numeric value
+ * @property {number} [minNumberValue=Number.MIN_SAFE_INTEGER] - Minimum numeric value
+ * @property {string} [enforcementMode='strict'] - Enforcement mode: 'strict', 'warn', 'soft'
+ * @property {boolean} [logViolations=true] - Whether to log limit violations
+ * @property {boolean} [throwOnViolation=true] - Whether to throw errors on limit violations
+ * @property {Function} [customValidator] - Custom function to validate data against limits
+ *   - Parameters: (data: any, limits: Object, context: Object) => boolean
+ *   - Return: true if valid, false if invalid
+ * @property {Object.<string, number>} [fieldLimits] - Field-specific size limits
+ *   - Key: field name (e.g., 'content', 'description')
+ *   - Value: maximum size in bytes
+ * @property {string[]} [excludeFields] - Array of field names to exclude from limit enforcement
+ * @property {string[]} [includeFields] - Array of field names to include in limit enforcement
+ * @property {boolean} [applyToInsert=true] - Whether to apply limits to insert operations
+ * @property {boolean} [applyToUpdate=true] - Whether to apply limits to update operations
+ * @property {boolean} [applyToUpsert=true] - Whether to apply limits to upsert operations
+ * @property {boolean} [applyToRead=false] - Whether to apply limits to read operations
+ * @property {number} [warningThreshold=0.8] - Percentage of limit to trigger warnings (0.8 = 80%)
+ * @property {Object} [context] - Additional context for custom functions
+ * @property {boolean} [validateMetadata=true] - Whether to validate metadata size
+ * @property {boolean} [validateBody=true] - Whether to validate body size
+ * @property {boolean} [validateKeys=true] - Whether to validate key sizes
+ * @property {boolean} [validateValues=true] - Whether to validate value sizes
+ * 
+ * @example
+ * // Basic configuration with standard limits
+ * {
+ *   enabled: true,
+ *   maxBodySize: 2 * 1024 * 1024, // 2MB
+ *   maxMetadataSize: 4096, // 4KB
+ *   maxFields: 200,
+ *   enforcementMode: 'strict',
+ *   logViolations: true
+ * }
+ * 
+ * @example
+ * // Configuration with field-specific limits
+ * {
+ *   enabled: true,
+ *   fieldLimits: {
+ *     'content': 5 * 1024 * 1024, // 5MB for content
+ *     'description': 1024 * 1024, // 1MB for description
+ *     'title': 1024, // 1KB for title
+ *     'tags': 512 // 512B for tags
+ *   },
+ *   excludeFields: ['id', 'created_at', 'updated_at'],
+ *   enforcementMode: 'warn',
+ *   warningThreshold: 0.7
+ * }
+ * 
+ * @example
+ * // Configuration with custom validation
+ * {
+ *   enabled: true,
+ *   maxBodySize: 1024 * 1024, // 1MB
+ *   customValidator: (data, limits, context) => {
+ *     // Custom validation logic
+ *     if (data.content && data.content.length > limits.maxBodySize) {
+ *       return false;
+ *     }
+ *     return true;
+ *   },
+ *   context: {
+ *     environment: 'production',
+ *     userRole: 'admin'
+ *   },
+ *   enforcementMode: 'soft',
+ *   logViolations: true
+ * }
+ * 
+ * @example
+ * // Configuration with strict limits for API endpoints
+ * {
+ *   enabled: true,
+ *   maxBodySize: 512 * 1024, // 512KB
+ *   maxMetadataSize: 1024, // 1KB
+ *   maxFields: 50,
+ *   maxNestingDepth: 5,
+ *   maxArrayLength: 100,
+ *   maxStringLength: 5000,
+ *   enforcementMode: 'strict',
+ *   throwOnViolation: true,
+ *   applyToInsert: true,
+ *   applyToUpdate: true,
+ *   applyToUpsert: true
+ * }
+ * 
+ * @example
+ * // Minimal configuration using defaults
+ * {
+ *   enabled: true,
+ *   maxBodySize: 1024 * 1024 // 1MB
+ * }
+ * 
+ * @notes
+ * - Default body size limit is 1MB (1024*1024 bytes)
+ * - Default metadata size limit is 2KB (2048 bytes)
+ * - Strict mode throws errors on violations
+ * - Warn mode logs violations but allows operations
+ * - Soft mode allows violations with warnings
+ * - Field-specific limits override global limits
+ * - Custom validators allow for specialized logic
+ * - Warning threshold helps prevent unexpected violations
+ * - Performance impact is minimal for most use cases
+ * - Limits help prevent abuse and ensure system stability
+ * - Context object is useful for conditional validation
+ * - Validation can be selectively applied to different operations
+ */
+
+/**
+ * Enforce Limits Behavior
+ * Throws error when metadata exceeds 2KB limit
+ */
+export async function handleInsert({ resource, data, mappedData, originalData }) {
+  const totalSize = calculateTotalSize(mappedData);
+  
+  // Calculate effective limit considering system overhead
+  const effectiveLimit = calculateEffectiveLimit({
+    s3Limit: S3_METADATA_LIMIT_BYTES,
+    systemConfig: {
+      version: resource.version,
+      timestamps: resource.config.timestamps,
+      id: data.id
+    }
+  });
+  
+  if (totalSize > effectiveLimit) {
+    throw new Error(`S3 metadata size exceeds 2KB limit. Current size: ${totalSize} bytes, effective limit: ${effectiveLimit} bytes, absolute limit: ${S3_METADATA_LIMIT_BYTES} bytes`);
+  }
+  return { mappedData, body: JSON.stringify(mappedData) };
+}
+
+export async function handleUpdate({ resource, id, data, mappedData, originalData }) {
+  const totalSize = calculateTotalSize(mappedData);
+  
+  // Calculate effective limit considering system overhead
+  const effectiveLimit = calculateEffectiveLimit({
+    s3Limit: S3_METADATA_LIMIT_BYTES,
+    systemConfig: {
+      version: resource.version,
+      timestamps: resource.config.timestamps,
+      id
+    }
+  });
+  
+  if (totalSize > effectiveLimit) {
+    throw new Error(`S3 metadata size exceeds 2KB limit. Current size: ${totalSize} bytes, effective limit: ${effectiveLimit} bytes, absolute limit: ${S3_METADATA_LIMIT_BYTES} bytes`);
+  }
+  return { mappedData, body: JSON.stringify(mappedData) };
+}
+
+export async function handleUpsert({ resource, id, data, mappedData }) {
+  const totalSize = calculateTotalSize(mappedData);
+  
+  // Calculate effective limit considering system overhead
+  const effectiveLimit = calculateEffectiveLimit({
+    s3Limit: S3_METADATA_LIMIT_BYTES,
+    systemConfig: {
+      version: resource.version,
+      timestamps: resource.config.timestamps,
+      id
+    }
+  });
+  
+  if (totalSize > effectiveLimit) {
+    throw new Error(`S3 metadata size exceeds 2KB limit. Current size: ${totalSize} bytes, effective limit: ${effectiveLimit} bytes, absolute limit: ${S3_METADATA_LIMIT_BYTES} bytes`);
+  }
+  return { mappedData, body: "" };
+}
+
+export async function handleGet({ resource, metadata, body }) {
+  // No special handling needed for enforce-limits behavior
+  return { metadata, body };
+}

package/src/behaviors/index.js

@@ -0,0 +1,39 @@
+import * as userManaged from './user-managed.js';
+import * as enforceLimits from './enforce-limits.js';
+import * as dataTruncate from './truncate-data.js';
+import * as bodyOverflow from './body-overflow.js';
+import * as bodyOnly from './body-only.js';
+
+/**
+ * Available behaviors for Resource metadata handling
+ */
+export const behaviors = {
+  'user-managed': userManaged,
+  'enforce-limits': enforceLimits,
+  'truncate-data': dataTruncate,
+  'body-overflow': bodyOverflow,
+  'body-only': bodyOnly
+};
+
+/**
+ * Get behavior implementation by name
+ * @param {string} behaviorName - Name of the behavior
+ * @returns {Object} Behavior implementation with handler functions
+ */
+export function getBehavior(behaviorName) {
+  const behavior = behaviors[behaviorName];
+  if (!behavior) {
+    throw new Error(`Unknown behavior: ${behaviorName}. Available behaviors: ${Object.keys(behaviors).join(', ')}`);
+  }
+  return behavior;
+}
+
+/**
+ * List of available behavior names
+ */
+export const AVAILABLE_BEHAVIORS = Object.keys(behaviors);
+
+/**
+ * Default behavior name
+ */
+export const DEFAULT_BEHAVIOR = 'user-managed';