@cedarjs/record 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# RedwoodRecord
+
+RedwoodRecord is an ORM ([Object-Relational Mapping](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping)) built on top of Prisma. It may be extended in the future to wrap other database access packages.
+
+RedwoodRecord is heavily inspired by [ActiveRecord](https://guides.rubyonrails.org/active_record_basics.html) which ships with [Ruby on Rails](https://rubyonrails.org). It presents a natural interface to the underlying data in your database, without worry about the particulars of SQL syntax.
+
+## Usage
+
+Usage documentation is available at https://redwoodjs.com/docs/redwoodrecord
+
+## Package Structure
+
+RedwoodRecord is composed of 5 classes total:
+
+1. **Core** - provides core database access for a single model, enabling CRUD actions
+2. **Reflection** - parses the Prisma data schema and determines what relations exist to other models
+3. **RelationProxy** - provides access to related models reveales by the Reflection class
+4. **ValidationMixin** - adds validation support, adding error messages
+5. **RedwoodRecord** - combines the functionality of the other four classes into the standard base class that all models should extend from
+
+There is also an `errors.js` file which contains all error messages that RedwoodRecord could throw.
+
+### Tasks
+
+RedwoodRecord depends on reading the Prisma schema file to determine relations to other tables. In order to avoid the `async` wait when parsing the schema with Prisma's built-in function, we have a task which parses the schema file and then saves out a JSON version to the cache `.redwood` directory. This task also creates an `index.js` file in your `api/src/models` directory that imports the models themselves and also adds some configuration to support relations without a circular dependency. The models are then re-exported.
+
+This task is run with:
+
+```
+yarn rw record init
+```
+
+This task needs to be run whenever you create a new model, or change your database schema in a way that would add/remove a relation to another model.
+
+> We plan to make the task run automatically, watching for changes to your schema.prisma or models directory. But for now you'll need to run it manually!

package/dist/cjs/errors.js

@@ -0,0 +1,75 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  RedwoodRecordError: () => RedwoodRecordError,
+  RedwoodRecordMissingAttributeError: () => RedwoodRecordMissingAttributeError,
+  RedwoodRecordMissingRequiredModelError: () => RedwoodRecordMissingRequiredModelError,
+  RedwoodRecordNotFoundError: () => RedwoodRecordNotFoundError,
+  RedwoodRecordNullAttributeError: () => RedwoodRecordNullAttributeError,
+  RedwoodRecordUncaughtError: () => RedwoodRecordUncaughtError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_api = require("@cedarjs/api");
+class RedwoodRecordError extends import_api.RedwoodError {
+  constructor() {
+    super();
+    this.name = "RedwoodRecordError";
+  }
+}
+class RedwoodRecordUncaughtError extends import_api.RedwoodError {
+  constructor(message) {
+    super(message);
+    this.name = "RedwoodRecordUncaughtError";
+  }
+}
+class RedwoodRecordNotFoundError extends import_api.RedwoodError {
+  constructor(name) {
+    super(`${name} record not found`);
+    this.name = "RedwoodRecordNotFoundError";
+  }
+}
+class RedwoodRecordNullAttributeError extends import_api.RedwoodError {
+  constructor(name) {
+    super(`${name} must not be null`);
+    this.name = "RedwoodRecordNullAttributeError";
+  }
+}
+class RedwoodRecordMissingAttributeError extends import_api.RedwoodError {
+  constructor(name) {
+    super(`${name} is missing`);
+    this.name = "RedwoodRecordMissingAttributeError";
+  }
+}
+class RedwoodRecordMissingRequiredModelError extends import_api.RedwoodError {
+  constructor(modelName, requiredModelName) {
+    super(
+      `Tried to build a relationship for ${requiredModelName} model but is not listed as a \`requiredModel\` in ${modelName}`
+    );
+    this.name = "RedwoodRecordMissingRequiredModelError";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedwoodRecordError,
+  RedwoodRecordMissingAttributeError,
+  RedwoodRecordMissingRequiredModelError,
+  RedwoodRecordNotFoundError,
+  RedwoodRecordNullAttributeError,
+  RedwoodRecordUncaughtError
+});

package/dist/cjs/index.js

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Core: () => import_Core.default,
+  RedwoodRecord: () => import_RedwoodRecord.default,
+  Reflection: () => import_Reflection.default,
+  RelationProxy: () => import_RelationProxy.default,
+  ValidationMixin: () => import_ValidationMixin.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./errors"), module.exports);
+var import_Core = __toESM(require("./redwoodrecord/Core"), 1);
+var import_Reflection = __toESM(require("./redwoodrecord/Reflection"), 1);
+var import_RelationProxy = __toESM(require("./redwoodrecord/RelationProxy"), 1);
+var import_ValidationMixin = __toESM(require("./redwoodrecord/ValidationMixin"), 1);
+var import_RedwoodRecord = __toESM(require("./redwoodrecord/RedwoodRecord"), 1);
+__reExport(index_exports, require("./tasks/parse"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Core,
+  RedwoodRecord,
+  Reflection,
+  RelationProxy,
+  ValidationMixin,
+  ...require("./errors"),
+  ...require("./tasks/parse")
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/redwoodrecord/Core.js

@@ -0,0 +1,265 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Core_exports = {};
+__export(Core_exports, {
+  default: () => Core
+});
+module.exports = __toCommonJS(Core_exports);
+var import_camelcase = __toESM(require("camelcase"), 1);
+var Errors = __toESM(require("../errors"), 1);
+class Core {
+  ////////////////////////////
+  // Public class properties
+  ////////////////////////////
+  // Set in child class to override DB accessor name. This is the name of the
+  // property you would call on an instance of Prisma Client in order the query
+  // a model in your schema. i.e. For the call `db.user` the accessorName is
+  // "user". Not setting this property will use the default camelCase version of
+  // the class name itself as the accessor.
+  //
+  //   static accessorName = 'users'
+  static accessorName;
+  // Set in child class to override primary key field name for this model.
+  //
+  //   static primaryKey = 'userId'
+  static primaryKey = "id";
+  // Parsed schema.prisma for use in subclasses
+  static schema = null;
+  // Any other model that may be required by this model
+  static requiredModels = [];
+  /////////////////////////
+  // Public class methods
+  /////////////////////////
+  // Access the raw Prisma Client for doing low level query manipulation
+  static db = null;
+  // Returns the Prisma DB accessor instance (ex. db.user)
+  static get accessor() {
+    return this.db[this.accessorName || (0, import_camelcase.default)(this.name)];
+  }
+  // Alias for where({})
+  static all(args) {
+    return this.where({}, args);
+  }
+  static build(attributes) {
+    const record = new this();
+    record.attributes = attributes;
+    return record;
+  }
+  // Create a new record. Instantiates a new instance and then calls .save() on it
+  static async create(attributes, options = {}) {
+    const record = this.build(attributes);
+    return await record.save(options);
+  }
+  // Find a single record by ID.
+  static async find(id, options = {}) {
+    const record = await this.findBy(
+      {
+        [this.primaryKey]: id,
+        ...options.where || {}
+      },
+      options
+    );
+    if (record === null) {
+      throw new Errors.RedwoodRecordNotFoundError(this.name);
+    }
+    return record;
+  }
+  // Returns the first record matching the given `where`, otherwise first in the
+  // whole table (whatever the DB determines is the first record)
+  static async findBy(attributes, options = {}) {
+    const record = await this.accessor.findFirst({
+      where: attributes,
+      ...options
+    });
+    return record ? await this.build(record) : null;
+  }
+  // Alias for findBy
+  static async first(...args) {
+    return this.findBy(...args);
+  }
+  // Find all records
+  static async where(attributes, options = {}) {
+    const records = await this.accessor.findMany({
+      where: attributes,
+      ...options
+    });
+    return Promise.all(
+      records.map(async (record) => {
+        return await this.build(record);
+      })
+    );
+  }
+  ///////////////////////////////
+  // Private instance properties
+  ///////////////////////////////
+  // Stores instance attributes object internally
+  #attributes = {};
+  ////////////////////////////
+  // Public instance methods
+  ////////////////////////////
+  constructor() {
+  }
+  get attributes() {
+    return this.#attributes;
+  }
+  set attributes(attrs) {
+    if (attrs) {
+      this.#attributes = attrs;
+      this._createPropertiesForAttributes();
+    }
+  }
+  async destroy(options = {}) {
+    const { throw: shouldThrow, ...rest } = options;
+    try {
+      await this.constructor.accessor.delete({
+        where: { [this.constructor.primaryKey]: this.attributes.id },
+        ...rest
+      });
+      return this;
+    } catch (e) {
+      this._deleteErrorHandler(e, shouldThrow);
+      return false;
+    }
+  }
+  // Saves the attributes to the database
+  async save(options = {}) {
+    const saveAttributes = JSON.parse(JSON.stringify(this.attributes));
+    try {
+      let newAttributes;
+      if (this.attributes[this.constructor.primaryKey]) {
+        delete saveAttributes[this.constructor.primaryKey];
+        newAttributes = await this.constructor.accessor.update({
+          where: {
+            [this.constructor.primaryKey]: this.attributes[this.constructor.primaryKey]
+          },
+          data: saveAttributes
+        });
+      } else {
+        newAttributes = await this.constructor.accessor.create({
+          data: saveAttributes
+        });
+      }
+      this.attributes = newAttributes;
+    } catch (e) {
+      this._saveErrorHandler(e, options.throw);
+      return false;
+    }
+    return this;
+  }
+  async update(attributes = {}, options = {}) {
+    this.#attributes = Object.assign(this.#attributes, attributes);
+    return await this.save(options);
+  }
+  ////////////////////////////
+  // Private instance methods
+  ////////////////////////////
+  // Turns a plain object's properties into getters/setters on the instance:
+  //
+  // const user = new User({ name: 'Rob' })
+  // user.name  // => 'Rob'
+  _createPropertiesForAttributes() {
+    for (const [name, value] of Object.entries(this.attributes)) {
+      if (this.hasOwnProperty(name)) {
+        continue;
+      }
+      if (value && typeof value === "object" && (Object.keys(value).includes("create") || Object.keys(value).includes("connect"))) {
+        continue;
+      }
+      this._createPropertyForAttribute(name);
+    }
+  }
+  // Create property for a single attribute
+  _createPropertyForAttribute(name) {
+    Object.defineProperty(this, name, {
+      get() {
+        return this._attributeGetter(name);
+      },
+      set(value) {
+        this._attributeSetter(name, value);
+      },
+      enumerable: true
+    });
+  }
+  _attributeGetter(name) {
+    return this.#attributes[name];
+  }
+  _attributeSetter(name, value) {
+    return this.#attributes[name] = value;
+  }
+  _onSaveError(_name, _message) {
+  }
+  _deleteErrorHandler(error, shouldThrow) {
+    if (error.message.match(/Record to delete does not exist/)) {
+      this._onSaveError(
+        "base",
+        `${this.constructor.name} record to destroy not found`
+      );
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordNotFoundError();
+      }
+    } else {
+      this._onSaveError(
+        "base",
+        `${this.constructor.name} record threw uncaught error: ${error.message}`
+      );
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordUncaughtError(error.message);
+      }
+    }
+  }
+  // Handles errors from saving a record (either update or create), converting
+  // to this.#errors messages, or throwing RedwoodRecord errors
+  _saveErrorHandler(error, shouldThrow) {
+    if (error.message.match(/Record to update not found/)) {
+      this._onSaveError(
+        "base",
+        `${this.constructor.name} record to update not found`
+      );
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordNotFoundError(this.constructor.name);
+      }
+    } else if (error.message.match(/must not be null/)) {
+      const [_all, name] = error.message.match(/Argument (\w+)/);
+      this._onSaveError(name, "must not be null");
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordNullAttributeError(name);
+      }
+    } else if (error.message.match(/is missing/)) {
+      const [_all, name] = error.message.match(/Argument (\w+)/);
+      this._onSaveError("base", `${name} is missing`);
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordMissingAttributeError(name);
+      }
+    } else {
+      this._onSaveError("base", error.message);
+      if (shouldThrow) {
+        throw new Errors.RedwoodRecordUncaughtError(error.message);
+      }
+    }
+  }
+}

package/dist/cjs/redwoodrecord/RedwoodRecord.js

@@ -0,0 +1,65 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RedwoodRecord_exports = {};
+__export(RedwoodRecord_exports, {
+  default: () => RedwoodRecord
+});
+module.exports = __toCommonJS(RedwoodRecord_exports);
+var import_Core = __toESM(require("./Core"), 1);
+var import_Reflection = __toESM(require("./Reflection"), 1);
+var import_RelationProxy = __toESM(require("./RelationProxy"), 1);
+var import_ValidationMixin = __toESM(require("./ValidationMixin"), 1);
+class RedwoodRecord extends (0, import_ValidationMixin.default)(import_Core.default) {
+  static get reflect() {
+    return new import_Reflection.default(this);
+  }
+  // Call original build, but add related attributes
+  static build(attributes) {
+    const record = super.build(attributes);
+    import_RelationProxy.default.addRelations(record, this.constructor.schema);
+    return record;
+  }
+  // Don't even try to save if data isn't valid
+  async save(options = {}) {
+    if (this.validate({ throw: options.throw })) {
+      return await super.save(options);
+    } else {
+      return false;
+    }
+  }
+  // Call original method, but add error keys for validation
+  _createPropertyForAttribute(name) {
+    super._createPropertyForAttribute(name);
+    this._errors[name] = [];
+  }
+  // Add validation error on save error
+  _onSaveError(...args) {
+    super._onSaveError(...args);
+    this.addError(...args);
+  }
+}

package/dist/cjs/redwoodrecord/Reflection.js

@@ -0,0 +1,100 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Reflection_exports = {};
+__export(Reflection_exports, {
+  default: () => Reflection
+});
+module.exports = __toCommonJS(Reflection_exports);
+class Reflection {
+  #hasMany = null;
+  #belongsTo = null;
+  #attributes = null;
+  constructor(model) {
+    this.model = model;
+  }
+  get attributes() {
+    if (!this.#attributes) {
+      this.#parseAttributes();
+    }
+    return this.#attributes;
+  }
+  get belongsTo() {
+    if (!this.#belongsTo) {
+      this.#parseBelongsTo();
+    }
+    return this.#belongsTo;
+  }
+  get hasMany() {
+    if (!this.#hasMany) {
+      this.#parseHasMany();
+    }
+    return this.#hasMany;
+  }
+  // Finds the schema for a single model
+  #schemaForModel(name = this.model.name) {
+    return this.model.schema.models.find((model) => model.name === name);
+  }
+  #parseHasMany() {
+    const selfSchema = this.#schemaForModel();
+    this.#hasMany = {};
+    selfSchema?.fields?.forEach((field) => {
+      if (field.isList) {
+        const otherSchema = this.#schemaForModel(field.type);
+        const belongsTo = otherSchema.fields.find(
+          (field2) => field2.type === this.model.name
+        );
+        this.#hasMany[field.name] = {
+          modelName: field.type,
+          referenceName: belongsTo.name,
+          // a null foreign key denotes an implicit many-to-many relationship
+          foreignKey: belongsTo.relationFromFields[0] || null,
+          primaryKey: belongsTo.relationToFields[0]
+        };
+      }
+    });
+  }
+  #parseBelongsTo() {
+    const selfSchema = this.#schemaForModel();
+    this.#belongsTo = {};
+    selfSchema?.fields?.forEach((field) => {
+      if (field.relationFromFields?.length) {
+        this.#belongsTo[field.name] = {
+          modelName: field.type,
+          foreignKey: field.relationFromFields[0],
+          primaryKey: field.relationToFields[0]
+        };
+      }
+    });
+  }
+  #parseAttributes() {
+    const selfSchema = this.#schemaForModel();
+    this.#attributes = {};
+    if (!this.#hasMany) {
+      this.#parseHasMany();
+    }
+    if (!this.belongsTo) {
+      this.#parseBelongsTo();
+    }
+    selfSchema?.fields?.forEach((field) => {
+      const { name, ...props } = field;
+      if (!Object.keys(this.#hasMany).includes(name) && !Object.keys(this.#belongsTo).includes(name)) {
+        this.#attributes[name] = props;
+      }
+    });
+  }
+}