@vsaas/loopback-datasource-juggler 10.0.0

package/dist/package.js

@@ -0,0 +1,93 @@
+//#region package.json
+var require_package = /* @__PURE__ */ require("./_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "@vsaas/loopback-datasource-juggler",
+		"version": "10.0.0",
+		"description": "Fork of loopback-datasource-juggler for LoopBack 3 style applications",
+		"keywords": [
+			"Connector",
+			"DataSource",
+			"Database",
+			"Juggler",
+			"LoopBack",
+			"ORM",
+			"StrongLoop"
+		],
+		"license": "MIT",
+		"author": "Xompass",
+		"repository": {
+			"type": "git",
+			"url": "https://github.com/xompass/loopback-datasource-juggler"
+		},
+		"files": [
+			"dist",
+			"connectors/*.js",
+			"types/**/*.d.ts",
+			"README.md",
+			"LICENSE",
+			"NOTICE"
+		],
+		"main": "dist/index.js",
+		"browser": { "depd": "./dist/lib/browser.depd.js" },
+		"types": "types/index.d.ts",
+		"exports": {
+			".": {
+				"types": "./types/index.d.ts",
+				"require": "./dist/index.js",
+				"default": "./dist/index.js"
+			},
+			"./browser.depd": {
+				"require": "./dist/lib/browser.depd.js",
+				"default": "./dist/lib/browser.depd.js"
+			},
+			"./*": {
+				"require": "./dist/lib/*.js",
+				"default": "./dist/lib/*.js"
+			},
+			"./package.json": "./package.json"
+		},
+		"publishConfig": {
+			"access": "public",
+			"registry": "https://registry.npmjs.org/"
+		},
+		"scripts": {
+			"build": "tsdown",
+			"fmt": "oxfmt -c ../.oxfmtrc.json .",
+			"lint": "oxlint -c ../.oxlintrc.json src",
+			"lint:fix": "oxlint -c ../.oxlintrc.json src --fix",
+			"prepack": "pnpm run build",
+			"prepublishOnly": "pnpm run typecheck && pnpm run lint && pnpm test",
+			"test:run": "vitest run",
+			"test": "pnpm run build && vitest run",
+			"typecheck": "tsc --noEmit -p tsconfig.json"
+		},
+		"dependencies": {
+			"@vsaas/loopback-connector": "workspace:^",
+			"debug": "^4.4.3",
+			"depd": "^2.0.0",
+			"inflection": "^3.0.2",
+			"minimatch": "10.2.4",
+			"neotraverse": "^0.6.18",
+			"qs": "^6.15.0"
+		},
+		"devDependencies": {
+			"@types/node": "catalog:",
+			"bson": "^4.7.2",
+			"loopback-connector-throwing": "workspace:*",
+			"oxfmt": "catalog:",
+			"oxlint": "catalog:",
+			"should": "^13.2.3",
+			"tsdown": "catalog:",
+			"typescript": "catalog:",
+			"vitest": "catalog:"
+		},
+		"engines": { "node": ">=20" }
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_package();
+	}
+});

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@vsaas/loopback-datasource-juggler",
+  "version": "10.0.0",
+  "description": "Fork of loopback-datasource-juggler for LoopBack 3 style applications",
+  "keywords": [
+    "Connector",
+    "DataSource",
+    "Database",
+    "Juggler",
+    "LoopBack",
+    "ORM",
+    "StrongLoop"
+  ],
+  "license": "MIT",
+  "author": "Xompass",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xompass/loopback-datasource-juggler"
+  },
+  "files": [
+    "dist",
+    "connectors/*.js",
+    "types/**/*.d.ts",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "main": "dist/index.js",
+  "browser": {
+    "depd": "./dist/lib/browser.depd.js"
+  },
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./browser.depd": {
+      "require": "./dist/lib/browser.depd.js",
+      "default": "./dist/lib/browser.depd.js"
+    },
+    "./*": {
+      "require": "./dist/lib/*.js",
+      "default": "./dist/lib/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "debug": "^4.4.3",
+    "depd": "^2.0.0",
+    "inflection": "^3.0.2",
+    "minimatch": "10.2.4",
+    "neotraverse": "^0.6.18",
+    "qs": "^6.15.0",
+    "@vsaas/loopback-connector": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.5.0",
+    "bson": "^4.7.2",
+    "oxfmt": "0.42.0",
+    "oxlint": "1.57.0",
+    "should": "^13.2.3",
+    "tsdown": "0.21.5",
+    "typescript": "6.0.2",
+    "vitest": "4.1.1",
+    "loopback-connector-throwing": "1.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "fmt": "oxfmt -c ../.oxfmtrc.json .",
+    "lint": "oxlint -c ../.oxlintrc.json src",
+    "lint:fix": "oxlint -c ../.oxlintrc.json src --fix",
+    "test:run": "vitest run",
+    "test": "pnpm run build && vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}

package/types/common.d.ts

@@ -0,0 +1,28 @@
+// Copyright IBM Corp. 2018,2019. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+/**
+ * Objects with open properties
+ */
+export interface AnyObject<T = any> {
+  [property: string]: T;
+}
+
+/**
+ * Type alias for options object
+ */
+export type Options = AnyObject<any>;
+
+/**
+ * Type alias for Node.js callback functions
+ */
+export type Callback<T = any> = (err?: any | null, result?: T) => void;
+
+/**
+ * Return export type for promisified Node.js async methods.
+ *
+ * Note that starting with version 4.0, juggler uses native Promises.
+ */
+export type PromiseOrVoid<T = any> = Promise<T> | void;

package/types/connector.d.ts

@@ -0,0 +1,52 @@
+// Copyright IBM Corp. 2018,2019. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { Callback, DataSource, Options, PromiseOrVoid } from '..';
+
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+/**
+ * Connector from `loopback-connector` module
+ */
+export interface Connector {
+  name: string; // Name/type of the connector
+  dataSource?: DataSource;
+  connect(callback?: Callback): PromiseOrVoid; // Connect to the underlying system
+  disconnect(callback?: Callback): PromiseOrVoid; // Disconnect from the underlying system
+  ping(callback?: Callback): PromiseOrVoid; // Ping the underlying system
+  execute?(...args: any[]): Promise<any>;
+  [property: string]: any; // Other properties that vary by connectors
+}
+
+/**
+ * Base connector class
+ */
+export declare class ConnectorBase implements Connector {
+  name: string; // Name/type of the connector;
+  dataSource?: DataSource;
+  connect(callback?: Callback): PromiseOrVoid; // Connect to the underlying system
+  disconnect(callback?: Callback): PromiseOrVoid; // Disconnect from the underlying system
+  ping(callback?: Callback): PromiseOrVoid; // Ping the underlying system
+  execute?(...args: any[]): Promise<any>;
+
+  /**
+   * Initialize the connector against the given data source
+   *
+   * @param {DataSource} dataSource The dataSource
+   * @param {Function} [callback] The callback function
+   */
+  static initialize(dataSource: DataSource, callback?: Callback): void;
+
+  constructor(settings?: Options);
+}
+
+export declare class Memory extends ConnectorBase {}
+
+export declare class KeyValueMemoryConnector extends ConnectorBase {}
+
+export declare class Transient extends ConnectorBase {}

package/types/datasource.d.ts

@@ -0,0 +1,324 @@
+// Copyright IBM Corp. 2018,2019. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { AnyObject, Callback, Options } from './common';
+import { Connector } from './connector';
+import { ModelBaseClass, ModelBuilder, ModelDefinition, PropertyDefinition } from './model';
+import { EventEmitter } from 'events';
+import { IsolationLevel, Transaction } from './transaction-mixin';
+
+/**
+ * LoopBack models can manipulate data via the DataSource object.
+ * Attaching a `DataSource` to a `Model` adds instance methods and static methods to the `Model`.
+ *
+ * Define a data source to persist model data.
+ * To create a DataSource programmatically, call `createDataSource()` on the LoopBack object; for example:
+ * ```js
+ * var oracle = loopback.createDataSource({
+ *   connector: 'oracle',
+ *   host: '111.22.333.44',
+ *   database: 'MYDB',
+ *   username: 'username',
+ *   password: 'password'
+ * });
+ * ```
+ *
+ * All classes in single dataSource share same the connector type and
+ * one database connection.
+ *
+ * For example, the following creates a DataSource, and waits for a connection callback.
+ *
+ * ```
+ * var dataSource = new DataSource('mysql', { database: 'myapp_test' });
+ * dataSource.define(...);
+ * dataSource.on('connected', function () {
+ *     // work with database
+ * });
+ * ```
+ * @class DataSource
+ * @param {String} [name] Optional name for datasource.
+ * @options {Object} settings Database-specific settings to establish connection (settings depend on specific connector).
+ * The table below lists a typical set for a relational database.
+ * @property {String} connector Database connector to use.  For any supported connector, can be any of:
+ *
+ * - The connector module from `require(connectorName)`.
+ * - The full name of the connector module, such as 'loopback-connector-oracle'.
+ * - The short name of the connector module, such as 'oracle'.
+ * - A local module under `./connectors/` folder.
+ * @property {String} host Database server host name.
+ * @property {String} port Database server port number.
+ * @property {String} username Database user name.
+ * @property {String} password Database password.
+ * @property {String} database Name of the database to use.
+ * @property {Boolean} debug Display debugging information. Default is false.
+ *
+ * The constructor allows the following styles:
+ *
+ * 1. new DataSource(dataSourceName, settings). For example:
+ *   - new DataSource('myDataSource', {connector: 'memory'});
+ *   - new DataSource('myDataSource', {name: 'myDataSource', connector: 'memory'});
+ *   - new DataSource('myDataSource', {name: 'anotherDataSource', connector: 'memory'});
+ *
+ * 2. new DataSource(settings). For example:
+ *   - new DataSource({name: 'myDataSource', connector: 'memory'});
+ *   - new DataSource({connector: 'memory'});
+ *
+ * 3. new DataSource(connectorModule, settings). For example:
+ *   - new DataSource(connectorModule, {name: 'myDataSource})
+ *   - new DataSource(connectorModule)
+ */
+export declare class DataSource extends EventEmitter {
+  name: string;
+  settings: Options;
+
+  initialized?: boolean;
+  connected?: boolean;
+  connecting?: boolean;
+
+  connector?: Connector;
+
+  definitions: { [modelName: string]: ModelDefinition };
+
+  DataAccessObject: AnyObject & { prototype: AnyObject };
+
+  constructor(name: string, settings?: Options, modelBuilder?: ModelBuilder);
+
+  constructor(settings?: Options, modelBuilder?: ModelBuilder);
+
+  constructor(connectorModule: Connector, settings?: Options, modelBuilder?: ModelBuilder);
+
+  /**
+   * Create a model class
+   * @param name Name of the model
+   * @param properties An object of property definitions
+   * @param options Options for model settings
+   */
+  createModel<T extends ModelBaseClass>(name: string, properties?: AnyObject, options?: Options): T;
+
+  /**
+   * Look up a model class by name
+   * @param modelName Model name
+   * @param forceCreate A flag to force creation of a model if not found
+   */
+  getModel(modelName: string, forceCreate?: boolean): ModelBaseClass | undefined;
+
+  /**
+   * Remove a model from the registry.
+   *
+   * @param modelName
+   */
+  deleteModelByName(modelName: string): void;
+
+  /**
+   * Remove all models from the registry, but keep the connector instance
+   * (including the pool of database connections).
+   */
+  deleteAllModels(): void;
+
+  /**
+   * Attach an existing model to a data source.
+   * This will mixin all of the data access object functions (DAO) into your
+   * modelClass definition.
+   * @param {ModelBaseClass} modelClass The model constructor that will be enhanced
+   * by DataAccessObject mixins.
+   */
+  attach(modelClass: ModelBaseClass): ModelBaseClass;
+
+  automigrate(models?: string | string[]): Promise<void>;
+  // legacy callback style
+  automigrate(models: string | string[] | undefined, callback: Callback): void;
+
+  autoupdate(models?: string | string[]): Promise<void>;
+  // legacy callback style
+  autoupdate(models: string | string[] | undefined, callback: Callback): void;
+
+  discoverModelDefinitions(options?: Options): Promise<ModelDefinition[]>;
+  // legacy callback style (no options)
+  discoverModelDefinitions(callback: Callback<ModelDefinition[]>): void;
+  // legacy callback style (with options)
+  discoverModelDefinitions(options: Options, callback: Callback<ModelDefinition[]>): void;
+
+  discoverModelProperties(modelName: string, options?: Options): Promise<PropertyDefinition[]>;
+  // legacy callback style (no options)
+  discoverModelProperties(modelName: string, callback: Callback<PropertyDefinition[]>): void;
+  // legacy callback style (with options)
+  discoverModelProperties(
+    modelName: string,
+    options: Options,
+    callback: Callback<PropertyDefinition[]>,
+  ): void;
+
+  discoverPrimaryKeys(modelName: string, options?: Options): Promise<PropertyDefinition[]>;
+  // legacy callback style (no options)
+  discoverPrimaryKeys(modelName: string, callback: Callback<PropertyDefinition[]>): void;
+  // legacy callback style (with options)
+  discoverPrimaryKeys(
+    modelName: string,
+    options: Options,
+    callback: Callback<PropertyDefinition[]>,
+  ): void;
+
+  discoverForeignKeys(modelName: string, options?: Options): Promise<PropertyDefinition[]>;
+  // legacy callback style (no options)
+  discoverForeignKeys(modelName: string, callback: Callback<PropertyDefinition[]>): void;
+  // legacy callback style (with options)
+  discoverForeignKeys(
+    modelName: string,
+    options: Options,
+    callback: Callback<PropertyDefinition[]>,
+  ): void;
+
+  discoverExportedForeignKeys(modelName: string, options?: Options): Promise<PropertyDefinition[]>;
+  // legacy callback style (no options)
+  discoverExportedForeignKeys(modelName: string, callback: Callback<PropertyDefinition[]>): void;
+  // legacy callback style (with options)
+  discoverExportedForeignKeys(
+    modelName: string,
+    options: Options,
+    callback: Callback<PropertyDefinition[]>,
+  ): void;
+
+  discoverAndBuildModels(
+    modelName: string,
+    options?: Options,
+  ): Promise<{ [name: string]: ModelBaseClass }>;
+  // legacy callback style (no options)
+  discoverAndBuildModels(
+    modelName: string,
+    callback: Callback<{ [name: string]: ModelBaseClass }>,
+  ): void;
+  // legacy callback style (with options)
+  discoverAndBuildModels(
+    modelName: string,
+    options: Options,
+    callback: Callback<{ [name: string]: ModelBaseClass }>,
+  ): void;
+
+  discoverSchema(tableName: string, options?: Options): Promise<AnyObject>;
+  // legacy callback style (no options)
+  discoverSchema(tableName: string, callback: Callback<AnyObject>): void;
+  // legacy callback style (with options)
+  discoverSchema(tableName: string, options: Options, callback: Callback<AnyObject>): void;
+
+  discoverSchemas(tableName: string, options?: Options): Promise<AnyObject[]>;
+  // legacy callback style (no options)
+  discoverSchemas(tableName: string, callback: Callback<AnyObject[]>): void;
+  // legacy callback style (with options)
+  discoverSchemas(tableName: string, options: Options, callback: Callback<AnyObject[]>): void;
+
+  buildModelFromInstance(
+    modelName: string,
+    jsonObject: AnyObject,
+    options?: Options,
+  ): ModelBaseClass;
+
+  connect(): Promise<void>;
+  // legacy callback style
+  connect(callback: Callback): void;
+
+  disconnect(): Promise<void>;
+  // legacy callback style
+  disconnect(callback: Callback): void;
+
+  // Only promise variant, callback is intentionally not described.
+  // Note we must use `void | PromiseLike<void>` to avoid breaking
+  // existing LoopBack 4 applications.
+  // TODO(semver-major): change the return type to `Promise<void>`
+  stop(): void | PromiseLike<void>;
+
+  ping(): Promise<void>;
+  // legacy callback style
+  ping(callback: Callback): void;
+
+  // Only promise variant, callback is intentionally not supported.
+
+  /**
+   * Execute a SQL command.
+   *
+   * **WARNING:** In general, it is always better to perform database actions
+   * through repository methods. Directly executing SQL may lead to unexpected
+   * results, corrupted data, security vulnerabilities and other issues.
+   *
+   * @example
+   *
+   * ```ts
+   * // MySQL
+   * const result = await db.execute(
+   *   'SELECT * FROM Products WHERE size > ?',
+   *   [42]
+   * );
+   *
+   * // PostgreSQL
+   * const result = await db.execute(
+   *   'SELECT * FROM Products WHERE size > $1',
+   *   [42]
+   * );
+   * ```
+   *
+   * @param command A parameterized SQL command or query.
+   * Check your database documentation for information on which characters to
+   * use as parameter placeholders.
+   * @param parameters List of parameter values to use.
+   * @param options Additional options, for example `transaction`.
+   * @returns A promise which resolves to the command output as returned by the
+   * database driver. The output type (data structure) is database specific and
+   * often depends on the command executed.
+   */
+  execute(command: string | object, parameters?: any[] | object, options?: Options): Promise<any>;
+
+  /**
+   * Execute a MongoDB command.
+   *
+   * **WARNING:** In general, it is always better to perform database actions
+   * through repository methods. Directly executing MongoDB commands may lead
+   * to unexpected results and other issues.
+   *
+   * @example
+   *
+   * ```ts
+   * const result = await db.execute('MyCollection', 'aggregate', [
+   *   {$lookup: {
+   *     // ...
+   *   }},
+   *   {$unwind: '$data'},
+   *   {$out: 'tempData'}
+   * ]);
+   * ```
+   *
+   * @param collectionName The name of the collection to execute the command on.
+   * @param command The command name. See
+   * [Collection API docs](http://mongodb.github.io/node-mongodb-native/3.6/api/Collection.html)
+   * for the list of commands supported by the MongoDB client.
+   * @param parameters Command parameters (arguments), as described in MongoDB API
+   * docs for individual collection methods.
+   * @returns A promise which resolves to the command output as returned by the
+   * database driver.
+   */
+  execute(collectionName: string, command: string, ...parameters: any[]): Promise<any>;
+
+  /**
+   * Execute a raw database command using a connector that's not described
+   * by LoopBack's `execute` API yet.
+   *
+   * **WARNING:** In general, it is always better to perform database actions
+   * through repository methods. Directly executing database commands may lead
+   * to unexpected results and other issues.
+   *
+   * @param args Command and parameters, please consult your connector's
+   * documentation to learn about supported commands and their parameters.
+   * @returns A promise which resolves to the command output as returned by the
+   * database driver.
+   */
+  execute(...args: any[]): Promise<any>;
+
+  /**
+   * Begin a new transaction.
+   *
+   *
+   * @param [options] Options {isolationLevel: '...', timeout: 1000}
+   * @returns Promise A promise which resolves to a Transaction object
+   */
+  beginTransaction(options?: IsolationLevel | Options): Promise<Transaction>;
+}

package/types/date-string.d.ts

@@ -0,0 +1,21 @@
+import { inspect } from 'util';
+
+// @achrinza: One of the limitations of these definitions is that the class instance
+//            isn't callable; Hence, changing the `value` class member must be done
+//            directly. This is a TypeScript limitation as class constructors cannot
+//            have a custom return value.
+export function DateString(value: DateString | string): DateString;
+export class DateString {
+  private _when: string;
+  private _date: Date;
+
+  get when(): string;
+  set when(val: string);
+
+  constructor(value: string);
+
+  toString(): DateString['when'];
+  toJSON(): { when: DateString['when'] };
+  inspect(): string;
+  [inspect.custom]: DateString['inspect'];
+}

package/types/inclusion-mixin.d.ts

@@ -0,0 +1,44 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import { PersistedData, PersistedModel } from '..';
+import { Callback, Options, PromiseOrVoid } from './common';
+import { Inclusion } from './query';
+
+/**
+ * Inclusion mixin
+ */
+export interface InclusionMixin {
+  /**
+   * Enables you to load relations of several objects and optimize numbers of requests.
+   *
+   * Examples:
+   *
+   * Load all users' posts with only one additional request:
+   * `User.include(users, 'posts', function() {});`
+   * Or
+   * `User.include(users, ['posts'], function() {});`
+   *
+   * Load all users posts and passports with two additional requests:
+   * `User.include(users, ['posts', 'passports'], function() {});`
+   *
+   * Load all passports owner (users), and all posts of each owner loaded:
+   *```Passport.include(passports, {owner: 'posts'}, function() {});
+   *``` Passport.include(passports, {owner: ['posts', 'passports']});
+   *``` Passport.include(passports, {owner: [{posts: 'images'}, 'passports']});
+   *
+   * @param {Array} objects Array of instances
+   * @param {String|Object|Array} include Which relations to load.
+   * @param {Object} [options] Options for CRUD
+   * @param {Function} cb Callback called when relations are loaded
+   *
+   */
+  include<T extends PersistedModel>(
+    objects: PersistedData<T>[],
+    include: Inclusion,
+    options?: Options,
+    callback?: Callback<PersistedData<T>[]>,
+  ): PromiseOrVoid<PersistedData<T>[]>;
+}

package/types/index.d.ts

@@ -0,0 +1,36 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: loopback-datasource-juggler
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+// Type definitions for loopback-datasource-juggler 3.x
+// Project: https://github.com/strongloop/loopback-datasource-juggler
+// Definitions by: Raymond Feng <https://github.com/raymondfeng>
+// TypeScript Version: 2.8
+
+/**
+ * Experimental TypeScript definitions to capture types of the key artifacts
+ * from `loopback-datasource-juggler` module. One of the main purposes is to
+ * leverage such types in `LoopBack 4`'s bridge to juggler.
+ *
+ * Please note some of the classes, properties, methods, and functions are
+ * intentionally not included in the definitions because of one of the following
+ * factors:
+ *
+ * - They are internal
+ * - They are to be deprecated
+ */
+export * from './common';
+export * from './model';
+export * from './relation';
+export * from './query';
+export * from './datasource';
+export * from './kv-model';
+export * from './persisted-model';
+export * from './scope';
+export * from './transaction-mixin';
+export * from './relation-mixin';
+export * from './observer-mixin';
+export * from './validation-mixin';
+export * from './inclusion-mixin';
+export * from './connector';