@cedarjs/record 0.0.4

package/dist/redwoodrecord/Reflection.js

@@ -0,0 +1,81 @@
+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;
+      }
+    });
+  }
+}
+export {
+  Reflection as default
+};

package/dist/redwoodrecord/RelationProxy.js

@@ -0,0 +1,109 @@
+import Reflection from "./Reflection";
+class RelationProxy {
+  static addRelations(record) {
+    const reflection = new Reflection(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);
+  }
+}
+export {
+  RelationProxy as default
+};

package/dist/redwoodrecord/ValidationMixin.js

@@ -0,0 +1,73 @@
+import { validate as validateField } from "@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 {
+        validateField(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);
+  }
+};
+export {
+  ValidationMixin_default as default
+};

package/dist/tasks/parse.js

@@ -0,0 +1,88 @@
+import fs from "fs";
+import path from "path";
+import { getDMMF, getSchema } from "@prisma/internals";
+import * as esbuild from "esbuild";
+import { getPaths } from "@cedarjs/project-config";
+const DATAMODEL_PATH = path.join(getPaths().api.models, "datamodel.js");
+const MODELS_PATH = path.join(getPaths().api.src, "models");
+const MODELS_INDEX_PATH = path.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 = getSchema(getPaths().api.dbSchema);
+  getDMMF({ datamodel: schema }).then((schema2) => {
+    datamodel = schema2.datamodel;
+    try {
+      const dir = path.dirname(DATAMODEL_PATH);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.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 = fs.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("");
+    fs.writeFileSync(MODELS_INDEX_PATH, indexLines.join("\n"));
+    console.info(`  Wrote ${MODELS_INDEX_PATH}
+`);
+  });
+};
+export {
+  parseDatamodel
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@cedarjs/record",
+  "version": "0.0.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/record"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts",
+    "build:pack": "yarn pack -o cedar-record.tgz",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build\"",
+    "check:package": "yarn publint",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@cedarjs/api": "0.0.4",
+    "@cedarjs/project-config": "0.0.4",
+    "@prisma/client": "5.20.0",
+    "camelcase": "6.3.0"
+  },
+  "devDependencies": {
+    "@cedarjs/framework-tools": "0.0.4",
+    "@prisma/internals": "5.20.0",
+    "esbuild": "0.25.0",
+    "publint": "0.3.11",
+    "tsx": "4.19.3",
+    "vitest": "2.1.9"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5b4f77f985bd86ee31ee7338312627accf0cb85b"
+}