@cedarjs/record 5.0.3 → 5.0.4-next.167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/record",
-  "version": "5.0.3",
+  "version": "5.0.4-next.167",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -9,13 +9,9 @@
   "license": "MIT",
   "type": "module",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "default": "./dist/cjs/index.js"
-    }
+    ".": "./dist/index.js"
   },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/index.js",
+  "main": "./dist/index.js",
   "files": [
     "dist"
   ],
@@ -29,17 +25,17 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@cedarjs/api": "5.0.3",
-    "@cedarjs/project-config": "5.0.3",
+    "@cedarjs/api": "5.0.4-next.167",
+    "@cedarjs/project-config": "5.0.4-next.167",
     "@prisma/client": "7.8.0",
     "camelcase": "6.3.0"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "5.0.3",
+    "@cedarjs/framework-tools": "5.0.4-next.167",
     "@prisma/internals": "7.8.0",
-    "esbuild": "0.27.7",
-    "publint": "0.3.21",
-    "vitest": "3.2.6"
+    "esbuild": "0.28.1",
+    "publint": "0.3.22",
+    "vitest": "4.1.10"
   },
   "engines": {
     "node": ">=24"

package/dist/cjs/errors.js

@@ -1,75 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

package/dist/cjs/redwoodrecord/Core.js

@@ -1,265 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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;
-      }
-    });
-  }
-}

package/dist/cjs/redwoodrecord/RelationProxy.js

@@ -1,138 +0,0 @@
-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 RelationProxy_exports = {};
-__export(RelationProxy_exports, {
-  default: () => RelationProxy
-});
-module.exports = __toCommonJS(RelationProxy_exports);
-var import_Reflection = __toESM(require("./Reflection"), 1);
-class RelationProxy {
-  static addRelations(record) {
-    const reflection = new import_Reflection.default(record.constructor);
-    this.#addHasManyRelations(record, reflection.hasMany);
-    this.#addBelongsToRelations(record, reflection.belongsTo);
-  }
-  static #addHasManyRelations(record, hasMany) {
-    for (const [name, options] of Object.entries(hasMany)) {
-      if (record.hasOwnProperty(name)) {
-        continue;
-      }
-      const model = record.constructor.requiredModels.find((requiredModel) => {
-        return requiredModel.name === options.modelName;
-      });
-      if (!model) {
-        console.warn(
-          `Model ${record.constructor.name} has a relationship defined for \`${name}\` in schema.prisma, but there is no Redwoood model for this relationship.`
-        );
-        continue;
-      }
-      Object.defineProperty(record, name, {
-        get() {
-          if (options.foreignKey === null) {
-            return new RelationProxy(model, {
-              where: {
-                [options.referenceName]: {
-                  some: { [options.primaryKey]: record[options.primaryKey] }
-                }
-              },
-              create: {
-                [options.referenceName]: {
-                  connect: [
-                    { [options.primaryKey]: record[options.primaryKey] }
-                  ]
-                }
-              }
-            });
-          } else {
-            return new RelationProxy(model, {
-              where: { [options.foreignKey]: record[options.primaryKey] }
-            });
-          }
-        },
-        enumerable: true
-      });
-    }
-  }
-  static #addBelongsToRelations(record, belongsTo) {
-    for (const [name, options] of Object.entries(belongsTo)) {
-      if (record.hasOwnProperty(name)) {
-        continue;
-      }
-      const model = record.constructor.requiredModels.find((requiredModel) => {
-        return requiredModel.name === options.modelName;
-      });
-      if (!model) {
-        console.warn(
-          `Model ${record.constructor.name} has a relationship defined for \`${name}\` in schema.prisma, but there is no Redwoood model for this relationship.`
-        );
-        continue;
-      }
-      Object.defineProperty(record, name, {
-        async get() {
-          return await model.findBy({
-            [options.primaryKey]: record[options.foreignKey]
-          });
-        },
-        enumerable: true
-      });
-    }
-  }
-  constructor(model, relation) {
-    this.model = model;
-    this.relation = relation;
-  }
-  all(...args) {
-    return this.where(...args);
-  }
-  create(attributes, options = {}) {
-    let relatedAttributes = { ...attributes };
-    if (this.relation.create) {
-      relatedAttributes = { ...relatedAttributes, ...this.relation.create };
-    } else {
-      relatedAttributes = { ...relatedAttributes, ...this.relation.where };
-    }
-    return this.model.create(relatedAttributes, options);
-  }
-  find(id, options = {}) {
-    return this.findBy({ [this.model.primaryKey]: id }, options);
-  }
-  findBy(attributes, options = {}) {
-    const relatedAttributes = {
-      ...attributes,
-      ...this.relation.where
-    };
-    return this.model.findBy(relatedAttributes, options);
-  }
-  first(...args) {
-    return this.findBy(...args);
-  }
-  where(attributes, options = {}) {
-    const relatedAttributes = { ...attributes, ...this.relation.where };
-    return this.model.where(relatedAttributes, options);
-  }
-}

package/dist/cjs/redwoodrecord/ValidationMixin.js

@@ -1,92 +0,0 @@
-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 ValidationMixin_exports = {};
-__export(ValidationMixin_exports, {
-  default: () => ValidationMixin_default
-});
-module.exports = __toCommonJS(ValidationMixin_exports);
-var import_api = require("@cedarjs/api");
-var ValidationMixin_default = (Base) => class extends Base {
-  // Stores error messages internally
-  _errors = { base: [] };
-  // Removes all error messages.
-  _clearErrors() {
-    for (const [attribute, _array] of Object.entries(this._errors)) {
-      this._errors[attribute] = [];
-    }
-  }
-  // Denotes validations that need to run for the given fields. Must be in the
-  // form of { field: options } where `field` is the name of the field and
-  // `options` are the validation options. See Service Validations docs for
-  // usage examples: https://cedarjs.com/docs/services.html#service-validations
-  //
-  //   static validates = {
-  //     emailAddress: { email: true },
-  //     name: { presence: true, length: { min: 2, max: 255 } }
-  //   }
-  static validates = {};
-  // Whether or not this instance is valid and has no errors. Essentially the
-  // opposite of `hasError`, but runs validations first. This means it will
-  // reset any custom errors added with `addError()`
-  get isValid() {
-    this.validate();
-    return !this.hasError;
-  }
-  get errors() {
-    return this._errors;
-  }
-  // Whether or not this instance contains any errors according to validation
-  // rules. Does not run valiations, (and so preserves custom errors) returns
-  // the state of error objects. Essentially the opposite of `isValid`.
-  get hasError() {
-    return !Object.entries(this._errors).every(
-      ([_name, errors]) => !errors.length
-    );
-  }
-  // Adds an error to the _errors object. Can be called manually via instance,
-  // however any errors added this way will be wiped out if calling `validate()`
-  addError(attribute, message) {
-    if (!this._errors[attribute]) {
-      this._errors[attribute] = [];
-    }
-    this._errors[attribute].push(message);
-  }
-  // Checks each field against validate directives. Creates errors if so and
-  // returns `false`, otherwise returns `true`.
-  validate(options = {}) {
-    this._clearErrors();
-    if (this.constructor.validates.length === 0) {
-      return true;
-    }
-    const results = [];
-    for (const [name, recipe] of Object.entries(this.constructor.validates)) {
-      try {
-        (0, import_api.validate)(this[name], name, recipe);
-        results.push(true);
-      } catch (e) {
-        this.addError(name, e.message);
-        if (options.throw) {
-          throw e;
-        } else {
-          results.push(false);
-        }
-      }
-    }
-    return results.every((result) => result);
-  }
-};

package/dist/cjs/tasks/parse.js

@@ -1,120 +0,0 @@
-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 parse_exports = {};
-__export(parse_exports, {
-  parseDatamodel: () => parseDatamodel
-});
-module.exports = __toCommonJS(parse_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_internals = require("@prisma/internals");
-var esbuild = __toESM(require("esbuild"), 1);
-var import_project_config = require("@cedarjs/project-config");
-const DATAMODEL_PATH = import_path.default.join((0, import_project_config.getPaths)().api.models, "datamodel.js");
-const MODELS_PATH = import_path.default.join((0, import_project_config.getPaths)().api.src, "models");
-const MODELS_INDEX_PATH = import_path.default.join(MODELS_PATH, "index.js");
-const indexLines = [
-  "// This file is autogenerated by Redwood and will be overwritten periodically",
-  "",
-  "import { db } from 'src/lib/db'",
-  "import datamodel from 'src/models/datamodel'",
-  "import { RedwoodRecord } from '@cedarjs/record'",
-  "",
-  "RedwoodRecord.db = db",
-  "RedwoodRecord.schema = datamodel",
-  ""
-];
-const modelImports = [];
-const modelRequires = {};
-const parseDatamodel = async () => {
-  const { schemas } = await (0, import_project_config.getPrismaSchemas)();
-  (0, import_internals.getDMMF)({ datamodel: schemas }).then((schema) => {
-    const datamodel = schema.datamodel;
-    try {
-      const dir = import_path.default.dirname(DATAMODEL_PATH);
-      if (!import_node_fs.default.existsSync(dir)) {
-        import_node_fs.default.mkdirSync(dir, { recursive: true });
-      }
-      import_node_fs.default.writeFileSync(
-        DATAMODEL_PATH,
-        esbuild.transformSync(JSON.stringify(datamodel, null, 2), {
-          loader: "json",
-          format: "cjs"
-        }).code
-      );
-      console.info(`
-  Wrote ${DATAMODEL_PATH}`);
-    } catch (e) {
-      console.error("Error writing datamodel to", DATAMODEL_PATH);
-    }
-    const modelNames = import_node_fs.default.readdirSync(MODELS_PATH).map((file) => {
-      if (file !== "index.js" && file !== "datamodel.js") {
-        return file.split(".")[0];
-      }
-    }).filter((val) => val);
-    if (modelNames.length === 0) {
-      console.warn("No models found in", MODELS_PATH);
-      console.warn(
-        "Please create a model to represent the database table you want to access."
-      );
-      return;
-    }
-    modelNames.forEach((modelName) => {
-      const thisModelRequires = [];
-      modelImports.push(`import ${modelName} from 'src/models/${modelName}'`);
-      const schemaModel = datamodel.models.find(
-        (model) => model.name === modelName
-      );
-      if (schemaModel) {
-        schemaModel.fields.forEach((field) => {
-          if (field.kind === "object" && modelNames.includes(field.type)) {
-            thisModelRequires.push(field.type);
-          }
-        });
-        modelRequires[modelName] = thisModelRequires;
-      }
-    });
-    modelImports.forEach((modelImport) => {
-      indexLines.push(modelImport);
-    });
-    indexLines.push("");
-    for (const [name, requires] of Object.entries(modelRequires)) {
-      indexLines.push(`${name}.requiredModels = [${requires.join(", ")}]`);
-    }
-    indexLines.push("");
-    indexLines.push(`export { ${modelNames.join(", ")} }`);
-    indexLines.push("");
-    import_node_fs.default.writeFileSync(MODELS_INDEX_PATH, indexLines.join("\n"));
-    console.info(`  Wrote ${MODELS_INDEX_PATH}
-`);
-  });
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parseDatamodel
-});