@cedarjs/record 0.0.4

package/dist/cjs/redwoodrecord/RelationProxy.js

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

@@ -0,0 +1,92 @@
+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://redwoodjs.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

@@ -0,0 +1,121 @@
+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_fs = __toESM(require("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 = {};
+let datamodel;
+const parseDatamodel = () => {
+  const schema = (0, import_internals.getSchema)((0, import_project_config.getPaths)().api.dbSchema);
+  (0, import_internals.getDMMF)({ datamodel: schema }).then((schema2) => {
+    datamodel = schema2.datamodel;
+    try {
+      const dir = import_path.default.dirname(DATAMODEL_PATH);
+      if (!import_fs.default.existsSync(dir)) {
+        import_fs.default.mkdirSync(dir, { recursive: true });
+      }
+      import_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_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_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
+});

package/dist/errors.js

@@ -0,0 +1,47 @@
+import { RedwoodError } from "@cedarjs/api";
+class RedwoodRecordError extends RedwoodError {
+  constructor() {
+    super();
+    this.name = "RedwoodRecordError";
+  }
+}
+class RedwoodRecordUncaughtError extends RedwoodError {
+  constructor(message) {
+    super(message);
+    this.name = "RedwoodRecordUncaughtError";
+  }
+}
+class RedwoodRecordNotFoundError extends RedwoodError {
+  constructor(name) {
+    super(`${name} record not found`);
+    this.name = "RedwoodRecordNotFoundError";
+  }
+}
+class RedwoodRecordNullAttributeError extends RedwoodError {
+  constructor(name) {
+    super(`${name} must not be null`);
+    this.name = "RedwoodRecordNullAttributeError";
+  }
+}
+class RedwoodRecordMissingAttributeError extends RedwoodError {
+  constructor(name) {
+    super(`${name} is missing`);
+    this.name = "RedwoodRecordMissingAttributeError";
+  }
+}
+class RedwoodRecordMissingRequiredModelError extends 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";
+  }
+}
+export {
+  RedwoodRecordError,
+  RedwoodRecordMissingAttributeError,
+  RedwoodRecordMissingRequiredModelError,
+  RedwoodRecordNotFoundError,
+  RedwoodRecordNullAttributeError,
+  RedwoodRecordUncaughtError
+};

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./errors";
+import { default as default2 } from "./redwoodrecord/Core";
+import { default as default3 } from "./redwoodrecord/Reflection";
+import { default as default4 } from "./redwoodrecord/RelationProxy";
+import { default as default5 } from "./redwoodrecord/ValidationMixin";
+import { default as default6 } from "./redwoodrecord/RedwoodRecord";
+export * from "./tasks/parse";
+export {
+  default2 as Core,
+  default6 as RedwoodRecord,
+  default3 as Reflection,
+  default4 as RelationProxy,
+  default5 as ValidationMixin
+};

package/dist/redwoodrecord/Core.js

@@ -0,0 +1,236 @@
+import camelCase from "camelcase";
+import * as Errors from "../errors";
+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 || camelCase(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);
+      }
+    }
+  }
+}
+export {
+  Core as default
+};

package/dist/redwoodrecord/RedwoodRecord.js

@@ -0,0 +1,36 @@
+import Core from "./Core";
+import Reflection from "./Reflection";
+import RelationProxy from "./RelationProxy";
+import ValidationMixin from "./ValidationMixin";
+class RedwoodRecord extends ValidationMixin(Core) {
+  static get reflect() {
+    return new Reflection(this);
+  }
+  // Call original build, but add related attributes
+  static build(attributes) {
+    const record = super.build(attributes);
+    RelationProxy.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);
+  }
+}
+export {
+  RedwoodRecord as default
+};