tessl/npm-loopback

LoopBack is a highly-extensible, open-source Node.js framework that enables developers to create dynamic end-to-end REST APIs with minimal coding.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Data Sources & Connectors

Name: tessl/npm-loopback
Author: tessl

LoopBack's flexible data source management system supports multiple database types and external services through a pluggable connector architecture, enabling seamless integration with various data storage and service backends.

Capabilities

Data Source Creation

Create and configure data sources with different connectors and connection settings.

/**
 * Create a data source with connector configuration
 * @param {string} name - Optional data source name
 * @param {Object} options - Data source configuration
 * @param {string|Function} options.connector - Connector name or constructor
 * @param {string} options.host - Database host
 * @param {number} options.port - Database port  
 * @param {string} options.database - Database name
 * @param {string} options.username - Database username
 * @param {string} options.password - Database password
 * @param {Object} options.settings - Additional connector settings
 * @returns {DataSource} Created data source instance
 */
loopback.createDataSource(name, options);

/**
 * Get or create in-memory data source
 * @param {string} name - Optional data source name (defaults to 'default')
 * @returns {DataSource} Memory data source instance
 */
loopback.memory(name);

Usage Examples:

// MySQL data source
const mysqlDB = loopback.createDataSource('mysql', {
  connector: 'mysql',
  host: 'localhost',
  port: 3306,
  database: 'myapp',
  username: 'dbuser',
  password: 'dbpass',
  acquireTimeout: 60000,
  timeout: 60000
});

// MongoDB data source
const mongodb = loopback.createDataSource('mongodb', {
  connector: 'mongodb',
  url: 'mongodb://localhost:27017/myapp',
  allowExtendedOperators: true
});

// PostgreSQL data source
const postgresDB = loopback.createDataSource('postgres', {
  connector: 'postgresql',
  host: 'localhost',
  port: 5432,
  database: 'myapp',
  username: 'dbuser',
  password: 'dbpass',
  ssl: false
});

// REST API data source
const apiService = loopback.createDataSource('api', {
  connector: 'rest',
  baseURL: 'https://api.example.com',
  headers: {
    'Authorization': 'Bearer token123'
  }
});

// In-memory data source
const memoryDB = loopback.memory('cache');

DataSource Class

The DataSource class from loopback-datasource-juggler provides database abstraction.

/**
 * DataSource constructor (from loopback-datasource-juggler)
 * @param {string} name - Data source name
 * @param {Object} settings - Data source settings
 * @param {Function} modelBuilder - Optional model builder
 */
const DataSource = loopback.DataSource;

/**
 * DataSource instance methods
 */

/**
 * Connect to the data source
 * @param {Function} callback - Callback function
 */
dataSource.connect(callback);

/**
 * Disconnect from the data source
 * @param {Function} callback - Callback function
 */
dataSource.disconnect(callback);

/**
 * Check if data source is connected
 * @returns {boolean} Connection status
 */
dataSource.connected();

/**
 * Ping the data source
 * @param {Function} callback - Callback function
 */
dataSource.ping(callback);

/**
 * Create model on this data source
 * @param {string} name - Model name
 * @param {Object} properties - Model properties
 * @param {Object} settings - Model settings
 * @returns {Function} Model constructor
 */
dataSource.createModel(name, properties, settings);

/**
 * Define model on this data source
 * @param {string} name - Model name
 * @param {Object} properties - Model properties
 * @param {Object} settings - Model settings
 * @returns {Function} Model constructor
 */
dataSource.define(name, properties, settings);

/**
 * Attach existing model to this data source
 * @param {Function} ModelCtor - Model constructor
 */
dataSource.attach(ModelCtor);

/**
 * Auto-migrate database schema
 * @param {string|string[]} models - Model names to migrate
 * @param {Function} callback - Callback function
 */
dataSource.automigrate(models, callback);

/**
 * Auto-update database schema
 * @param {string|string[]} models - Model names to update
 * @param {Function} callback - Callback function
 */
dataSource.autoupdate(models, callback);

/**
 * Check if database exists
 * @param {Function} callback - Callback function
 */
dataSource.isActual(callback);

Built-in Connectors

LoopBack includes several built-in connectors for common data sources.

/**
 * Memory connector for in-memory storage
 */
const Memory = loopback.Memory;

/**
 * Memory connector constructor
 * @param {Object} settings - Connector settings
 */
function Memory(settings);

/**
 * Mail connector for email services
 */
const Mail = loopback.Mail;

/**
 * Mail connector constructor  
 * @param {Object} settings - Mail settings
 * @param {Object} settings.transports - Transport configurations
 * @param {string} settings.transports.type - Transport type
 */
function Mail(settings);

/**
 * Remote connector for REST APIs
 */
const Remote = loopback.Remote;

/**
 * Base connector class
 */
const Connector = loopback.Connector;

/**
 * Base connector constructor
 * @param {Object} settings - Connector settings
 */
function Connector(settings);

Mail Connector Configuration

Email sending capabilities through various transport providers.

/**
 * Mail connector with transport configuration
 */
const mailConnector = {
  connector: Mail,
  transports: [
    {
      type: 'smtp',
      host: 'smtp.gmail.com',
      port: 587,
      secure: false,
      auth: {
        user: 'sender@gmail.com',
        pass: 'password'
      }
    },
    {
      type: 'direct',
      name: 'localhost'
    },
    {
      type: 'stub' // For testing
    }
  ]
};

/**
 * Mail connector methods
 */

/**
 * Setup email transport
 */
mailConnector.setupTransport();

/**
 * Get transport by name
 * @param {string} name - Transport name
 * @returns {Object} Transport instance
 */
mailConnector.transportForName(name);

/**
 * Get default transport
 * @returns {Object} Default transport
 */
mailConnector.defaultTransport();

/**
 * Mailer class for sending emails
 */
class Mailer {
  /**
   * Send email message
   * @param {Object} options - Email options
   * @param {string} options.from - Sender address
   * @param {string} options.to - Recipient address
   * @param {string} options.subject - Email subject
   * @param {string} options.text - Plain text content
   * @param {string} options.html - HTML content
   * @param {Function} callback - Callback function
   */
  send(options, callback);
}

Usage Example:

// Configure mail data source
const emailDS = loopback.createDataSource('email', {
  connector: loopback.Mail,
  transports: [{
    type: 'smtp',
    host: 'smtp.gmail.com',
    port: 587,
    secure: false,
    auth: {
      user: process.env.EMAIL_USER,
      pass: process.env.EMAIL_PASS
    }
  }]
});

// Attach Email model to mail data source
app.model(loopback.Email, { dataSource: emailDS });

Connector Registration

/**
 * Register connector with application (from application.js)
 * @param {string} name - Connector name
 * @param {Function} connector - Connector constructor
 */
app.connector(name, connector);

Usage Example:

// Register custom connector
app.connector('custom', MyCustomConnector);

// Use custom connector
const customDS = app.dataSource('custom', {
  connector: 'custom',
  customOption: 'value'
});

Key-Value Store Connector

Built-in key-value store connector for simple storage operations.

/**
 * Key-value memory connector (from datasource-juggler)
 */
const kvMemory = require('loopback-datasource-juggler/lib/connectors/kv-memory');

/**
 * Key-value operations available through KeyValueModel
 */

/**
 * Get value by key
 * @param {string} key - Key to retrieve
 * @param {Function} callback - Callback function
 */
KeyValueModel.get(key, callback);

/**
 * Set key-value pair
 * @param {string} key - Key to set
 * @param {*} value - Value to store
 * @param {number} ttl - Time to live in seconds (optional)
 * @param {Function} callback - Callback function
 */
KeyValueModel.set(key, value, ttl, callback);

/**
 * Set expiration for key
 * @param {string} key - Key to expire
 * @param {number} ttl - Time to live in seconds
 * @param {Function} callback - Callback function
 */
KeyValueModel.expire(key, ttl, callback);

/**
 * Get time to live for key
 * @param {string} key - Key to check
 * @param {Function} callback - Callback function
 */
KeyValueModel.ttl(key, callback);

/**
 * Delete key
 * @param {string} key - Key to delete
 * @param {Function} callback - Callback function
 */
KeyValueModel.delete(key, callback);

/**
 * Get all keys matching pattern
 * @param {string} pattern - Key pattern (* for all)
 * @param {Function} callback - Callback function
 */
KeyValueModel.keys(pattern, callback);

Usage Example:

// Create key-value data source
const kvStore = loopback.createDataSource('kv', {
  connector: 'kv-memory'
});

// Attach KeyValueModel
const Cache = loopback.createModel('Cache', {}, {
  base: 'KeyValueModel'
});
Cache.attachTo(kvStore);

// Use key-value operations
Cache.set('user:123', { name: 'John', age: 30 }, 3600, (err) => {
  if (err) return console.error(err);
  
  Cache.get('user:123', (err, user) => {
    console.log('Retrieved user:', user);
  });
});

Data Source Configuration Types

Configuration interfaces for different data source types.

/**
 * Common data source settings
 */
interface DataSourceSettings {
  connector: string | Function;    // Connector name or constructor
  host?: string;                  // Database host
  port?: number;                  // Database port
  database?: string;              // Database name
  username?: string;              // Database username
  password?: string;              // Database password
  url?: string;                   // Connection URL
  debug?: boolean;                // Enable debug mode
  lazyConnect?: boolean;          // Lazy connection
}

/**
 * MySQL/PostgreSQL specific settings
 */
interface SQLDataSourceSettings extends DataSourceSettings {
  acquireTimeout?: number;        // Connection acquire timeout
  timeout?: number;               // Query timeout
  reconnectTries?: number;        // Reconnection attempts
  ssl?: boolean | Object;         // SSL configuration
  timezone?: string;              // Database timezone
}

/**
 * MongoDB specific settings
 */
interface MongoDataSourceSettings extends DataSourceSettings {
  allowExtendedOperators?: boolean;   // Allow MongoDB operators
  enableGeoIndexing?: boolean;        // Enable geo indexing
  maxPoolSize?: number;              // Connection pool size
  authSource?: string;               // Authentication database
}

/**
 * REST API specific settings
 */
interface RESTDataSourceSettings extends DataSourceSettings {
  baseURL: string;                   // API base URL
  headers?: Object;                  // Default headers
  timeout?: number;                  // Request timeout
  auth?: Object;                     // Authentication config
  proxy?: string;                    // Proxy configuration
}

/**
 * Mail specific settings
 */
interface MailDataSourceSettings extends DataSourceSettings {
  transports: Array<{
    type: string;                    // Transport type (smtp, direct, stub)
    host?: string;                   // SMTP host
    port?: number;                   // SMTP port
    secure?: boolean;                // Use SSL/TLS
    auth?: {                        // Authentication
      user: string;
      pass: string;
    };
  }>;
}