s3db.js 6.1.0 → 7.0.0

package/src/plugins/plugin.class.js

@@ -0,0 +1,210 @@
+import EventEmitter from "events";
+
+export class Plugin extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.name = this.constructor.name;
+    this.options = options;
+    this.hooks = new Map();
+  }
+
+  async setup(database) {
+    this.database = database;
+    this.beforeSetup();
+    await this.onSetup();
+    this.afterSetup();
+  }
+
+  async start() {
+    this.beforeStart();
+    await this.onStart();
+    this.afterStart();
+  }
+
+  async stop() {
+    this.beforeStop();
+    await this.onStop();
+    this.afterStop();
+  }
+
+  // Override these methods in subclasses
+  async onSetup() {
+    // Override in subclasses
+  }
+
+  async onStart() {
+    // Override in subclasses
+  }
+
+  async onStop() {
+    // Override in subclasses
+  }
+
+  // Hook management methods
+  addHook(resource, event, handler) {
+    if (!this.hooks.has(resource)) {
+      this.hooks.set(resource, new Map());
+    }
+    
+    const resourceHooks = this.hooks.get(resource);
+    if (!resourceHooks.has(event)) {
+      resourceHooks.set(event, []);
+    }
+    
+    resourceHooks.get(event).push(handler);
+  }
+
+  removeHook(resource, event, handler) {
+    const resourceHooks = this.hooks.get(resource);
+    if (resourceHooks && resourceHooks.has(event)) {
+      const handlers = resourceHooks.get(event);
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+
+  // Enhanced resource method wrapping that supports multiple plugins
+  wrapResourceMethod(resource, methodName, wrapper) {
+    const originalMethod = resource[methodName];
+    
+    if (!resource._pluginWrappers) {
+      resource._pluginWrappers = new Map();
+    }
+    
+    if (!resource._pluginWrappers.has(methodName)) {
+      resource._pluginWrappers.set(methodName, []);
+    }
+    
+    // Store the wrapper
+    resource._pluginWrappers.get(methodName).push(wrapper);
+    
+    // Create the wrapped method if it doesn't exist
+    if (!resource[`_wrapped_${methodName}`]) {
+      resource[`_wrapped_${methodName}`] = originalMethod;
+      
+      // Preserve jest mock if it's a mock function
+      const isJestMock = originalMethod && originalMethod._isMockFunction;
+      
+      resource[methodName] = async function(...args) {
+        let result = await resource[`_wrapped_${methodName}`](...args);
+        
+        // Apply all wrappers in order
+        for (const wrapper of resource._pluginWrappers.get(methodName)) {
+          result = await wrapper.call(this, result, args, methodName);
+        }
+        
+        return result;
+      };
+      
+      // Preserve jest mock properties if it was a mock
+      if (isJestMock) {
+        Object.setPrototypeOf(resource[methodName], Object.getPrototypeOf(originalMethod));
+        Object.assign(resource[methodName], originalMethod);
+      }
+    }
+  }
+
+  /**
+   * Add a middleware to intercept a resource method (Koa/Express style).
+   * Middleware signature: async (next, ...args) => { ... }
+   * - Chame next(...args) para continuar a cadeia.
+   * - Retorne sem chamar next para interromper.
+   * - Pode modificar argumentos/resultados.
+   */
+  addMiddleware(resource, methodName, middleware) {
+    if (!resource._pluginMiddlewares) {
+      resource._pluginMiddlewares = {};
+    }
+    if (!resource._pluginMiddlewares[methodName]) {
+      resource._pluginMiddlewares[methodName] = [];
+      // Wrap the original method only once
+      const originalMethod = resource[methodName].bind(resource);
+      resource[methodName] = async function(...args) {
+        let idx = -1;
+        const next = async (...nextArgs) => {
+          idx++;
+          if (idx < resource._pluginMiddlewares[methodName].length) {
+            // Call next middleware
+            return await resource._pluginMiddlewares[methodName][idx].call(this, next, ...nextArgs);
+          } else {
+            // Call original method
+            return await originalMethod(...nextArgs);
+          }
+        };
+        return await next(...args);
+      };
+    }
+    resource._pluginMiddlewares[methodName].push(middleware);
+  }
+
+  // Partition-aware helper methods
+  getPartitionValues(data, resource) {
+    if (!resource.config?.partitions) return {};
+    
+    const partitionValues = {};
+    for (const [partitionName, partitionDef] of Object.entries(resource.config.partitions)) {
+      if (partitionDef.fields) {
+        partitionValues[partitionName] = {};
+        for (const [fieldName, rule] of Object.entries(partitionDef.fields)) {
+          const value = this.getNestedFieldValue(data, fieldName);
+          // Only add field if value exists
+          if (value !== null && value !== undefined) {
+            partitionValues[partitionName][fieldName] = resource.applyPartitionRule(value, rule);
+          }
+        }
+      } else {
+        partitionValues[partitionName] = {};
+      }
+    }
+    
+    return partitionValues;
+  }
+
+  getNestedFieldValue(data, fieldPath) {
+    if (!fieldPath.includes('.')) {
+      return data[fieldPath] ?? null;
+    }
+    
+    const keys = fieldPath.split('.');
+    let value = data;
+    
+    for (const key of keys) {
+      if (value && typeof value === 'object' && key in value) {
+        value = value[key];
+      } else {
+        return null;
+      }
+    }
+    
+    return value ?? null;
+  }
+
+  // Event emission methods
+  beforeSetup() {
+    this.emit("plugin.beforeSetup", new Date());
+  }
+
+  afterSetup() {
+    this.emit("plugin.afterSetup", new Date());
+  }
+
+  beforeStart() {
+    this.emit("plugin.beforeStart", new Date());
+  }
+
+  afterStart() {
+    this.emit("plugin.afterStart", new Date());
+  }
+
+  beforeStop() {
+    this.emit("plugin.beforeStop", new Date());
+  }
+
+  afterStop() {
+    this.emit("plugin.afterStop", new Date());
+  }
+}
+
+export default Plugin;

package/src/plugins/plugin.obj.js

@@ -0,0 +1,13 @@
+export const PluginObject = {
+  setup(database) {
+    // TODO: implement me!
+  },
+
+  start() {
+    // TODO: implement me!
+  },
+
+  stop() {
+    // TODO: implement me!
+  },
+}

package/src/plugins/queue-consumer.plugin.js

@@ -0,0 +1,134 @@
+import { createConsumer } from './consumers/index.js';
+import tryFn from "../concerns/try-fn.js";
+
+// Exemplo de configuração para SQS:
+// const plugin = new QueueConsumerPlugin({
+//   driver: 'sqs',
+//   queues: { users: 'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue' },
+//   region: 'us-east-1',
+//   credentials: { accessKeyId: '...', secretAccessKey: '...' },
+//   poolingInterval: 1000,
+//   maxMessages: 10,
+// });
+//
+// Exemplo de configuração para RabbitMQ:
+// const plugin = new QueueConsumerPlugin({
+//   driver: 'rabbitmq',
+//   queues: { users: 'users-queue' },
+//   amqpUrl: 'amqp://user:pass@localhost:5672',
+//   prefetch: 10,
+//   reconnectInterval: 2000,
+// });
+
+export default class QueueConsumerPlugin {
+  constructor(options = {}) {
+    this.options = options;
+    // Novo padrão: consumers = [{ driver, config, consumers: [{ queueUrl, resources, ... }] }]
+    this.driversConfig = Array.isArray(options.consumers) ? options.consumers : [];
+    this.consumers = [];
+  }
+
+  async setup(database) {
+    this.database = database;
+    
+    for (const driverDef of this.driversConfig) {
+      const { driver, config: driverConfig = {}, consumers: consumerDefs = [] } = driverDef;
+      
+      // Handle legacy format where config is mixed with driver definition
+      if (consumerDefs.length === 0 && driverDef.resources) {
+        // Legacy format: { driver: 'sqs', resources: 'users', config: {...} }
+        const { resources, driver: defDriver, config: nestedConfig, ...directConfig } = driverDef;
+        const resourceList = Array.isArray(resources) ? resources : [resources];
+        
+        // Flatten config - prioritize nested config if it exists, otherwise use direct config
+        const flatConfig = nestedConfig ? { ...directConfig, ...nestedConfig } : directConfig;
+        
+        for (const resource of resourceList) {
+          const consumer = createConsumer(driver, {
+            ...flatConfig,
+            onMessage: (msg) => this._handleMessage(msg, resource),
+            onError: (err, raw) => this._handleError(err, raw, resource)
+          });
+          
+          await consumer.start();
+          this.consumers.push(consumer);
+        }
+      } else {
+        // New format: { driver: 'sqs', config: {...}, consumers: [{ resources: 'users', ... }] }
+        for (const consumerDef of consumerDefs) {
+          const { resources, ...consumerConfig } = consumerDef;
+          const resourceList = Array.isArray(resources) ? resources : [resources];
+          for (const resource of resourceList) {
+            const mergedConfig = { ...driverConfig, ...consumerConfig };
+            const consumer = createConsumer(driver, {
+              ...mergedConfig,
+              onMessage: (msg) => this._handleMessage(msg, resource),
+              onError: (err, raw) => this._handleError(err, raw, resource)
+            });
+            await consumer.start();
+            this.consumers.push(consumer);
+          }
+        }
+      }
+    }
+  }
+
+  async stop() {
+    if (!Array.isArray(this.consumers)) this.consumers = [];
+    for (const consumer of this.consumers) {
+      if (consumer && typeof consumer.stop === 'function') {
+        await consumer.stop();
+      }
+    }
+    this.consumers = [];
+  }
+
+  async _handleMessage(msg, configuredResource) {
+    const opt = this.options;
+    // Permitir resource/action/data tanto na raiz quanto em $body
+    // Handle double nesting from SQS parsing
+    let body = msg.$body || msg;
+    if (body.$body && !body.resource && !body.action && !body.data) {
+      // Double nested case - use the inner $body
+      body = body.$body;
+    }
+    
+    let resource = body.resource || msg.resource;
+    let action = body.action || msg.action;
+    let data = body.data || msg.data;
+    
+
+    
+    if (!resource) {
+      throw new Error('QueueConsumerPlugin: resource not found in message');
+    }
+    if (!action) {
+      throw new Error('QueueConsumerPlugin: action not found in message');
+    }
+    const resourceObj = this.database.resources[resource];
+    if (!resourceObj) throw new Error(`QueueConsumerPlugin: resource '${resource}' not found`);
+    
+    let result;
+    const [ok, err, res] = await tryFn(async () => {
+      if (action === 'insert') {
+        result = await resourceObj.insert(data);
+      } else if (action === 'update') {
+        const { id: updateId, ...updateAttributes } = data;
+        result = await resourceObj.update(updateId, updateAttributes);
+      } else if (action === 'delete') {
+        result = await resourceObj.delete(data.id);
+      } else {
+        throw new Error(`QueueConsumerPlugin: unsupported action '${action}'`);
+      }
+      return result;
+    });
+    
+    if (!ok) {
+      throw err;
+    }
+    return res;
+  }
+
+  _handleError(err, raw, resourceName) {
+  }
+}