@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/utils/promiseUtils/map.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const { isPromise } = require('./isPromise');
+
+// Works like Bluebird.map.
+function promiseMap(items, mapper, opt) {
+  switch (items.length) {
+    case 0:
+      return mapZero();
+    case 1:
+      return mapOne(items, mapper);
+    default:
+      return mapMany(items, mapper, opt);
+  }
+}
+
+function mapZero() {
+  return Promise.resolve([]);
+}
+
+function mapOne(items, mapper) {
+  try {
+    const maybePromise = mapper(items[0], 0);
+
+    if (isPromise(maybePromise)) {
+      return maybePromise.then(wrapArray);
+    } else {
+      return Promise.resolve(wrapArray(maybePromise));
+    }
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+function wrapArray(item) {
+  return [item];
+}
+
+function mapMany(items, mapper, opt = {}) {
+  return new Promise((resolve, reject) => {
+    const concurrency = opt.concurrency || Number.MAX_SAFE_INTEGER;
+
+    const ctx = {
+      reject,
+      resolve,
+      rejected: false,
+      index: 0,
+      numFinished: 0,
+      results: new Array(items.length),
+      items,
+      mapper,
+    };
+
+    while (ctx.index < concurrency && ctx.index < items.length && !ctx.rejected) {
+      executeNext(ctx);
+    }
+  });
+}
+
+function executeNext(ctx) {
+  try {
+    if (ctx.rejected) {
+      return;
+    }
+
+    const index = ctx.index++;
+    const item = ctx.items[index];
+    const maybePromise = ctx.mapper(item, index);
+
+    if (isPromise(maybePromise)) {
+      maybePromise
+        .then((result) => afterExecute(ctx, result, index))
+        .catch((err) => onError(ctx, err));
+    } else {
+      process.nextTick(() => afterExecute(ctx, maybePromise, index));
+    }
+
+    return null;
+  } catch (err) {
+    onError(ctx, err);
+  }
+}
+
+function afterExecute(ctx, result, index) {
+  if (ctx.rejected) {
+    return null;
+  }
+
+  ctx.results[index] = result;
+  ctx.numFinished++;
+
+  if (ctx.numFinished === ctx.items.length) {
+    ctx.resolve(ctx.results);
+  }
+
+  if (ctx.index < ctx.items.length) {
+    executeNext(ctx);
+  }
+
+  return null;
+}
+
+function onError(ctx, err) {
+  ctx.rejected = true;
+  ctx.reject(err);
+}
+
+module.exports = {
+  promiseMap,
+};

package/lib/utils/promiseUtils/mapAfterAllReturn.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { isPromise } = require('./isPromise');
+
+// Map `arr` with `mapper` and after that return `returnValue`. If none of
+// the mapped values is a promise, return synchronously for performance
+// reasons.
+function mapAfterAllReturn(arr, mapper, returnValue) {
+  const results = new Array(arr.length);
+  let containsPromise = false;
+
+  for (let i = 0, l = arr.length; i < l; ++i) {
+    results[i] = mapper(arr[i]);
+
+    if (isPromise(results[i])) {
+      containsPromise = true;
+    }
+  }
+
+  if (containsPromise) {
+    return Promise.all(results).then(() => returnValue);
+  } else {
+    return returnValue;
+  }
+}
+
+module.exports = {
+  mapAfterAllReturn,
+};

package/lib/utils/promiseUtils/try.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { isPromise } = require('./isPromise');
+
+// Works like Bluebird.try.
+function promiseTry(callback) {
+  try {
+    const maybePromise = callback();
+
+    if (isPromise(maybePromise)) {
+      return maybePromise;
+    } else {
+      return Promise.resolve(maybePromise);
+    }
+  } catch (err) {
+    return Promise.reject(err);
+  }
+}
+
+module.exports = {
+  promiseTry,
+};

package/lib/utils/resolveModel.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const path = require('path');
+const { isString, isFunction } = require('../utils/objectUtils');
+
+class ResolveError extends Error {}
+
+function resolveModel(modelRef, modelPaths, errorPrefix) {
+  try {
+    if (isString(modelRef)) {
+      if (isAbsolutePath(modelRef)) {
+        return requireModel(modelRef);
+      } else if (modelPaths) {
+        return requireUsingModelPaths(modelRef, modelPaths);
+      }
+    } else {
+      if (isFunction(modelRef) && !isModelClass(modelRef)) {
+        modelRef = modelRef();
+      }
+
+      if (!isModelClass(modelRef)) {
+        throw new ResolveError(
+          `is not a subclass of Model or a file path to a module that exports one. You may be dealing with a require loop. See the documentation section about require loops.`,
+        );
+      }
+
+      return modelRef;
+    }
+  } catch (err) {
+    if (err instanceof ResolveError) {
+      throw new Error(`${errorPrefix}: ${err.message}`);
+    } else {
+      throw err;
+    }
+  }
+}
+
+function requireUsingModelPaths(modelRef, modelPaths) {
+  let firstError = null;
+
+  for (const modelPath of modelPaths) {
+    try {
+      return requireModel(path.join(modelPath, modelRef));
+    } catch (err) {
+      if (firstError === null) {
+        firstError = err;
+      }
+    }
+  }
+
+  if (firstError) {
+    throw firstError;
+  } else {
+    throw new ResolveError(`could not resolve ${modelRef} using modelPaths`);
+  }
+}
+
+function requireModel(modelPath) {
+  /**
+   * Wrap path string in template literal to prevent
+   * warnings about Objection.JS being an expression
+   * in webpack builds.
+   * @link https://github.com/webpack/webpack/issues/196
+   */
+  let mod = require(`${path.resolve(modelPath)}`);
+  let modelClass = null;
+
+  if (isModelClass(mod)) {
+    modelClass = mod;
+  } else if (isModelClass(mod.default)) {
+    // Babel 6 style of exposing default export.
+    modelClass = mod.default;
+  } else {
+    Object.keys(mod).forEach((exportName) => {
+      const exp = mod[exportName];
+
+      if (isModelClass(exp)) {
+        if (modelClass !== null) {
+          throw new ResolveError(
+            `path ${modelPath} exports multiple models. Don't know which one to choose.`,
+          );
+        }
+
+        modelClass = exp;
+      }
+    });
+  }
+
+  if (!isModelClass(modelClass)) {
+    throw new ResolveError(`${modelPath} is an invalid file path to a model class`);
+  }
+
+  return modelClass;
+}
+
+function isAbsolutePath(pth) {
+  return path.normalize(pth + '/') === path.normalize(path.resolve(pth) + '/');
+}
+
+function isModelClass(maybeModel) {
+  return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
+}
+
+module.exports = {
+  resolveModel,
+  isModelClass,
+};

package/lib/utils/tmpColumnUtils.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const OWNER_JOIN_COLUMN_ALIAS_PREFIX = 'objectiontmpjoin';
+
+function getTempColumn(index) {
+  return `${OWNER_JOIN_COLUMN_ALIAS_PREFIX}${index}`;
+}
+
+function isTempColumn(col) {
+  return col.startsWith(OWNER_JOIN_COLUMN_ALIAS_PREFIX);
+}
+
+module.exports = {
+  getTempColumn,
+  isTempColumn,
+};

package/package.json

@@ -1,6 +1,88 @@
 {
   "name": "@abedmurrar/objection",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "4.0.0-alpha.0",
+  "description": "An SQL-friendly ORM for Node.js. A fork of objection.js with strict TypeScript types and MySQL support.",
+  "main": "lib/objection.js",
+  "license": "MIT",
+  "scripts": {
+    "test": "npm run eslint && mocha --slow 10 --timeout 15000 --reporter spec --recursive tests --exclude \"tests/unit/relations/files/**\" && npm run test:typings",
+    "test:fast": "mocha --slow 10 --timeout 15000 --reporter spec --recursive tests --bail --exclude \"tests/unit/relations/files/**\"",
+    "test:typings": "node scripts/generate-fn-typings.js --check && tsc && tsc -p tests/ts/tsconfig.loose.json && node scripts/typings-errors.js",
+    "test:typings:ts7": "npx -y -p typescript@7 tsc -p tests/ts/tsconfig.ts7.json",
+    "bench:typings": "node scripts/typings-bench.js",
+    "prettier": "prettier --write \"{examples,lib,tests,testUtils,typings,doc}/**/*.{js,ts}\"",
+    "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\"",
+    "docs:dev": "vuepress dev doc",
+    "docs:build": "vuepress build doc",
+    "release": "node scripts/release.js",
+    "prepublishOnly": "npm run eslint && npm run test:typings"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": {
+    "name": "Abed Murrar",
+    "url": "https://github.com/abedmurrar"
+  },
+  "contributors": [
+    "Sami Koskimäki <sami@jakso.me> (https://github.com/koskimas)",
+    "Mikael Lepistö <mikael.lepisto@vincit.com> (https://github.com/elhigu)",
+    "Matthew McEachen <matthew-objection@photostructure.com> (https://github.com/mceachen)",
+    "Jürg Lehni <juerg@scratchdisk.com> (https://github.com/lehni)",
+    "Igor Savin <kibertoad@gmail.com> (https://github.com/kibertoad)"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abedmurrar/objection.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/abedmurrar/objection.js/issues"
+  },
+  "homepage": "https://github.com/abedmurrar/objection.js#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "orm",
+    "knex",
+    "sql",
+    "query",
+    "query builder",
+    "postgresql",
+    "mysql",
+    "sqlite3"
+  ],
+  "files": [
+    "README.md",
+    "LICENSE",
+    "lib/*",
+    "typings/*"
+  ],
+  "types": "./typings/objection/index.d.ts",
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1",
+    "db-errors": "^0.2.3"
+  },
+  "peerDependencies": {
+    "knex": ">=3.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "chai": "^4.3.10",
+    "chai-subset": "^1.6.0",
+    "eslint": "^8.54.0",
+    "eslint-formatter-codeframe": "^7.32.1",
+    "eslint-plugin-prettier": "^5.3.1",
+    "expect.js": "^0.3.1",
+    "knex": "^3.3.0",
+    "mocha": "^11.2.2",
+    "mysql2": "^3.24.6",
+    "pg": "^8.15.6",
+    "prettier": "3.5.3",
+    "sqlite3": "^5.1.7",
+    "typescript": "~5.8.3",
+    "vuepress": "1.9.10"
+  }
+}