velocious 1.0.325 → 1.0.326

package/build/src/database/record/validators/uniqueness.d.ts

@@ -1,4 +1,24 @@
 export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
+    /**
+     * Try to resolve a scope column value from a loaded belongsTo
+     * relationship on the model. When a Task is created via
+     * `new Task({project})`, the FK (`projectId`) is only flushed onto
+     * the attribute store during save — but the relationship object is
+     * already loaded and carries the id we need for the WHERE clause.
+     *
+     * @param {import("../index.js").default} model
+     * @param {string} scopeColumn - camelCase attribute name (e.g. `"projectId"`).
+     * @returns {string | number | null}
+     */
+    _resolveScopeValueFromRelationship(model: import("../index.js").default, scopeColumn: string): string | number | null;
+    /**
+     * Normalize the `scope` option into an array of attribute names.
+     * Supports string (`"userId"`), array of strings (`["userId", "projectId"]`),
+     * or absent (empty array — no scope, original single-column behavior).
+     *
+     * @returns {string[]}
+     */
+    _normalizeScopeColumns(): string[];
 }
 import Base from "./base.js";
 //# sourceMappingURL=uniqueness.d.ts.map

package/build/src/database/record/validators/uniqueness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniqueness.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/validators/uniqueness.js"],"names":[],"mappings":"AAKA;CAoCC;iBAvCgB,WAAW"}
+{"version":3,"file":"uniqueness.d.ts","sourceRoot":"","sources":["../../../../../src/database/record/validators/uniqueness.js"],"names":[],"mappings":"AAKA;IA2DE;;;;;;;;;;OAUG;IACH,0CAJW,OAAO,aAAa,EAAE,OAAO,eAC7B,MAAM,GACJ,MAAM,GAAG,MAAM,GAAG,IAAI,CAwBlC;IAED;;;;;;OAMG;IACH,0BAFa,MAAM,EAAE,CASpB;CACF;iBAhHgB,WAAW"}

package/build/src/database/record/validators/uniqueness.js

@@ -17,6 +17,24 @@ export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
         /** @type {Record<string, string | number>} */
         const whereArgs = {};
         whereArgs[attributeNameUnderscore] = attributeValue;
+        // Rails parity: `validates :attr, uniqueness: {scope: :other}` adds
+        // the scoped column(s) to the WHERE clause so uniqueness is checked
+        // within the given scope (e.g. `role` unique per `userId`).
+        const scopeColumns = this._normalizeScopeColumns();
+        for (const scopeColumn of scopeColumns) {
+            const scopeUnderscore = inflection.underscore(scopeColumn);
+            let scopeValue = model.readAttribute(scopeColumn);
+            // When the FK hasn't been flushed from the relationship object
+            // onto the attribute store yet (e.g. `new Task({project})` where
+            // `projectId` is still undefined), try resolving it from the
+            // loaded belongsTo relationship instead.
+            if (scopeValue == null) {
+                scopeValue = this._resolveScopeValueFromRelationship(model, scopeColumn);
+            }
+            if (scopeValue == null)
+                return;
+            whereArgs[scopeUnderscore] = /** @type {string | number} */ (scopeValue);
+        }
         let existingRecordQuery = modelClass
             .select(modelClass.primaryKey())
             .where(whereArgs);
@@ -30,5 +48,49 @@ export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
             model._validationErrors[attributeName].push({ type: "uniqueness", message: "has already been taken" });
         }
     }
+    /**
+     * Try to resolve a scope column value from a loaded belongsTo
+     * relationship on the model. When a Task is created via
+     * `new Task({project})`, the FK (`projectId`) is only flushed onto
+     * the attribute store during save — but the relationship object is
+     * already loaded and carries the id we need for the WHERE clause.
+     *
+     * @param {import("../index.js").default} model
+     * @param {string} scopeColumn - camelCase attribute name (e.g. `"projectId"`).
+     * @returns {string | number | null}
+     */
+    _resolveScopeValueFromRelationship(model, scopeColumn) {
+        const modelClass = /** @type {typeof import("../index.js").default} */ (model.constructor);
+        const relationships = modelClass.getRelationshipsMap();
+        for (const relationshipName in relationships) {
+            const relationship = relationships[relationshipName];
+            if (relationship.getType?.() !== "belongsTo")
+                continue;
+            const foreignKey = inflection.camelize(relationship.getForeignKey(), true);
+            if (foreignKey !== scopeColumn)
+                continue;
+            const instanceRelationship = model.getRelationshipByName(relationshipName);
+            const loaded = instanceRelationship.loaded();
+            if (loaded && !Array.isArray(loaded) && typeof loaded.id === "function") {
+                return loaded.id();
+            }
+        }
+        return null;
+    }
+    /**
+     * Normalize the `scope` option into an array of attribute names.
+     * Supports string (`"userId"`), array of strings (`["userId", "projectId"]`),
+     * or absent (empty array — no scope, original single-column behavior).
+     *
+     * @returns {string[]}
+     */
+    _normalizeScopeColumns() {
+        const scope = this.args?.scope;
+        if (!scope)
+            return [];
+        if (Array.isArray(scope))
+            return scope;
+        return [String(scope)];
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlbmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9kYXRhYmFzZS9yZWNvcmQvdmFsaWRhdG9ycy91bmlxdWVuZXNzLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLElBQUksTUFBTSxXQUFXLENBQUE7QUFDNUIsT0FBTyxLQUFLLFVBQVUsTUFBTSxZQUFZLENBQUE7QUFFeEMsTUFBTSxDQUFDLE9BQU8sT0FBTywyQ0FBNEMsU0FBUSxJQUFJO0lBQzNFOzs7OztPQUtHO0lBQ0gsS0FBSyxDQUFDLFFBQVEsQ0FBQyxFQUFDLEtBQUssRUFBRSxhQUFhLEVBQUM7UUFDbkMsTUFBTSxVQUFVLEdBQUcsbURBQW1ELENBQUMsQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUE7UUFFMUYsTUFBTSxVQUFVLEdBQUcsVUFBVSxDQUFDLFVBQVUsRUFBRSxDQUFBO1FBQzFDLE1BQU0sU0FBUyxHQUFHLFVBQVUsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQTtRQUNsRCxNQUFNLGNBQWMsR0FBRyw4QkFBOEIsQ0FBQyxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQTtRQUMxRixNQUFNLHVCQUF1QixHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUE7UUFFcEUsOENBQThDO1FBQzlDLE1BQU0sU0FBUyxHQUFHLEVBQUUsQ0FBQTtRQUVwQixTQUFTLENBQUMsdUJBQXVCLENBQUMsR0FBRyxjQUFjLENBQUE7UUFFbkQsSUFBSSxtQkFBbUIsR0FBRyxVQUFVO2FBQ2pDLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBVSxFQUFFLENBQUM7YUFDL0IsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFBO1FBRW5CLElBQUksS0FBSyxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7WUFDeEIsbUJBQW1CLENBQUMsS0FBSyxDQUFDLEdBQUcsVUFBVSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsSUFBSSxVQUFVLENBQUMsV0FBVyxDQUFDLFVBQVUsQ0FBQyxVQUFVLEVBQUUsQ0FBQyxPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFBO1FBQ3hKLENBQUM7UUFFRCxNQUFNLGNBQWMsR0FBRyxNQUFNLG1CQUFtQixDQUFDLEtBQUssRUFBRSxDQUFBO1FBRXhELElBQUksY0FBYyxFQUFFLENBQUM7WUFDbkIsSUFBSSxDQUFDLENBQUMsYUFBYSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQztnQkFBRSxLQUFLLENBQUMsaUJBQWlCLENBQUMsYUFBYSxDQUFDLEdBQUcsRUFBRSxDQUFBO1lBRTVGLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxhQUFhLENBQUMsQ0FBQyxJQUFJLENBQUMsRUFBQyxJQUFJLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBQyxDQUFDLENBQUE7UUFDdEcsQ0FBQztJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1jaGVja1xuXG5pbXBvcnQgQmFzZSBmcm9tIFwiLi9iYXNlLmpzXCJcbmltcG9ydCAqIGFzIGluZmxlY3Rpb24gZnJvbSBcImluZmxlY3Rpb25cIlxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBWZWxvY2lvdXNEYXRhYmFzZVJlY29yZFZhbGlkYXRvcnNVbmlxdWVuZXNzIGV4dGVuZHMgQmFzZSB7XG4gIC8qKlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMgb2JqZWN0LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4uL2luZGV4LmpzXCIpLmRlZmF1bHR9IGFyZ3MubW9kZWwgLSBNb2RlbCBpbnN0YW5jZS5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuYXR0cmlidXRlTmFtZSAtIEF0dHJpYnV0ZSBuYW1lLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBSZXNvbHZlcyB3aGVuIGNvbXBsZXRlLlxuICAgKi9cbiAgYXN5bmMgdmFsaWRhdGUoe21vZGVsLCBhdHRyaWJ1dGVOYW1lfSkge1xuICAgIGNvbnN0IG1vZGVsQ2xhc3MgPSAvKiogQHR5cGUge3R5cGVvZiBpbXBvcnQoXCIuLi9pbmRleC5qc1wiKS5kZWZhdWx0fSAqLyAobW9kZWwuY29uc3RydWN0b3IpXG5cbiAgICBjb25zdCBjb25uZWN0aW9uID0gbW9kZWxDbGFzcy5jb25uZWN0aW9uKClcbiAgICBjb25zdCB0YWJsZU5hbWUgPSBtb2RlbENsYXNzLl9nZXRUYWJsZSgpLmdldE5hbWUoKVxuICAgIGNvbnN0IGF0dHJpYnV0ZVZhbHVlID0gLyoqIEB0eXBlIHtzdHJpbmcgfCBudW1iZXJ9ICovIChtb2RlbC5yZWFkQXR0cmlidXRlKGF0dHJpYnV0ZU5hbWUpKVxuICAgIGNvbnN0IGF0dHJpYnV0ZU5hbWVVbmRlcnNjb3JlID0gaW5mbGVjdGlvbi51bmRlcnNjb3JlKGF0dHJpYnV0ZU5hbWUpXG5cbiAgICAvKiogQHR5cGUge1JlY29yZDxzdHJpbmcsIHN0cmluZyB8IG51bWJlcj59ICovXG4gICAgY29uc3Qgd2hlcmVBcmdzID0ge31cblxuICAgIHdoZXJlQXJnc1thdHRyaWJ1dGVOYW1lVW5kZXJzY29yZV0gPSBhdHRyaWJ1dGVWYWx1ZVxuXG4gICAgbGV0IGV4aXN0aW5nUmVjb3JkUXVlcnkgPSBtb2RlbENsYXNzXG4gICAgICAuc2VsZWN0KG1vZGVsQ2xhc3MucHJpbWFyeUtleSgpKVxuICAgICAgLndoZXJlKHdoZXJlQXJncylcblxuICAgIGlmIChtb2RlbC5pc1BlcnNpc3RlZCgpKSB7XG4gICAgICBleGlzdGluZ1JlY29yZFF1ZXJ5LndoZXJlKGAke2Nvbm5lY3Rpb24ucXVvdGVUYWJsZSh0YWJsZU5hbWUpfS4ke2Nvbm5lY3Rpb24ucXVvdGVDb2x1bW4obW9kZWxDbGFzcy5wcmltYXJ5S2V5KCkpfSAhPSAke2Nvbm5lY3Rpb24ucXVvdGUobW9kZWwuaWQoKSl9YClcbiAgICB9XG5cbiAgICBjb25zdCBleGlzdGluZ1JlY29yZCA9IGF3YWl0IGV4aXN0aW5nUmVjb3JkUXVlcnkuZmlyc3QoKVxuXG4gICAgaWYgKGV4aXN0aW5nUmVjb3JkKSB7XG4gICAgICBpZiAoIShhdHRyaWJ1dGVOYW1lIGluIG1vZGVsLl92YWxpZGF0aW9uRXJyb3JzKSkgbW9kZWwuX3ZhbGlkYXRpb25FcnJvcnNbYXR0cmlidXRlTmFtZV0gPSBbXVxuXG4gICAgICBtb2RlbC5fdmFsaWRhdGlvbkVycm9yc1thdHRyaWJ1dGVOYW1lXS5wdXNoKHt0eXBlOiBcInVuaXF1ZW5lc3NcIiwgbWVzc2FnZTogXCJoYXMgYWxyZWFkeSBiZWVuIHRha2VuXCJ9KVxuICAgIH1cbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uniqueness.js","sourceRoot":"","sources":["../../../../../src/database/record/validators/uniqueness.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Base from \"./base.js\"\nimport * as inflection from \"inflection\"\n\nexport default class VelociousDatabaseRecordValidatorsUniqueness extends Base {\n  /**\n   * @param {object} args - Options object.\n   * @param {import(\"../index.js\").default} args.model - Model instance.\n   * @param {string} args.attributeName - Attribute name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async validate({model, attributeName}) {\n    const modelClass = /** @type {typeof import(\"../index.js\").default} */ (model.constructor)\n\n    const connection = modelClass.connection()\n    const tableName = modelClass._getTable().getName()\n    const attributeValue = /** @type {string | number} */ (model.readAttribute(attributeName))\n    const attributeNameUnderscore = inflection.underscore(attributeName)\n\n    /** @type {Record<string, string | number>} */\n    const whereArgs = {}\n\n    whereArgs[attributeNameUnderscore] = attributeValue\n\n    // Rails parity: `validates :attr, uniqueness: {scope: :other}` adds\n    // the scoped column(s) to the WHERE clause so uniqueness is checked\n    // within the given scope (e.g. `role` unique per `userId`).\n    const scopeColumns = this._normalizeScopeColumns()\n\n    for (const scopeColumn of scopeColumns) {\n      const scopeUnderscore = inflection.underscore(scopeColumn)\n      let scopeValue = model.readAttribute(scopeColumn)\n\n      // When the FK hasn't been flushed from the relationship object\n      // onto the attribute store yet (e.g. `new Task({project})` where\n      // `projectId` is still undefined), try resolving it from the\n      // loaded belongsTo relationship instead.\n      if (scopeValue == null) {\n        scopeValue = this._resolveScopeValueFromRelationship(model, scopeColumn)\n      }\n\n      if (scopeValue == null) return\n\n      whereArgs[scopeUnderscore] = /** @type {string | number} */ (scopeValue)\n    }\n\n    let existingRecordQuery = modelClass\n      .select(modelClass.primaryKey())\n      .where(whereArgs)\n\n    if (model.isPersisted()) {\n      existingRecordQuery.where(`${connection.quoteTable(tableName)}.${connection.quoteColumn(modelClass.primaryKey())} != ${connection.quote(model.id())}`)\n    }\n\n    const existingRecord = await existingRecordQuery.first()\n\n    if (existingRecord) {\n      if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []\n\n      model._validationErrors[attributeName].push({type: \"uniqueness\", message: \"has already been taken\"})\n    }\n  }\n\n  /**\n   * Try to resolve a scope column value from a loaded belongsTo\n   * relationship on the model. When a Task is created via\n   * `new Task({project})`, the FK (`projectId`) is only flushed onto\n   * the attribute store during save — but the relationship object is\n   * already loaded and carries the id we need for the WHERE clause.\n   *\n   * @param {import(\"../index.js\").default} model\n   * @param {string} scopeColumn - camelCase attribute name (e.g. `\"projectId\"`).\n   * @returns {string | number | null}\n   */\n  _resolveScopeValueFromRelationship(model, scopeColumn) {\n    const modelClass = /** @type {typeof import(\"../index.js\").default} */ (model.constructor)\n    const relationships = modelClass.getRelationshipsMap()\n\n    for (const relationshipName in relationships) {\n      const relationship = relationships[relationshipName]\n\n      if (relationship.getType?.() !== \"belongsTo\") continue\n\n      const foreignKey = inflection.camelize(relationship.getForeignKey(), true)\n\n      if (foreignKey !== scopeColumn) continue\n\n      const instanceRelationship = model.getRelationshipByName(relationshipName)\n      const loaded = instanceRelationship.loaded()\n\n      if (loaded && !Array.isArray(loaded) && typeof loaded.id === \"function\") {\n        return loaded.id()\n      }\n    }\n\n    return null\n  }\n\n  /**\n   * Normalize the `scope` option into an array of attribute names.\n   * Supports string (`\"userId\"`), array of strings (`[\"userId\", \"projectId\"]`),\n   * or absent (empty array — no scope, original single-column behavior).\n   *\n   * @returns {string[]}\n   */\n  _normalizeScopeColumns() {\n    const scope = this.args?.scope\n\n    if (!scope) return []\n    if (Array.isArray(scope)) return scope\n\n    return [String(scope)]\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.325",
+  "version": "1.0.326",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [