@bedrockio/model 0.21.0 → 0.21.2

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.21.2
+
+- Export `loadDefinition` and readme updates.
+
+## 0.21.1
+
+- Fixed issues with schema loading.
+
 ## 0.21.0
 
 - Allow comments in schemas with .jsonc.

package/README.md

@@ -6,6 +6,7 @@ Bedrock utilities for model creation.
 - [Dependencies](#dependencies)
 - [Usage](#usage)
 - [Schemas](#schemas)
+  - [Schema Comments](#schema-comments)
 - [Schema Extensions](#schema-extensions)
   - [Attributes](#attributes)
   - [Scopes](#scopes)
@@ -58,14 +59,13 @@ const { loadModelDir } = require('@bedrockio/model');
 model.exports = loadModelDir('path/to/definitions/');
 ```
 
-Models that need to be extended can use the `createSchema` method with the
-definition and add to the schema as needed:
+Models that need to be extended can use the `loadSchema` method.
 
 ```js
 const mongoose = require('mongoose');
-const definition = require('./definitions/user.json');
+const { loadSchema } = require('@bedrockio/model')
 
-const schema = createSchema(definition);
+const schema = loadSchema('user');
 
 schema.virtual('name').get(function () {
   return [this.firstName, this.lastName].join(' ');
@@ -89,7 +89,7 @@ model.exports = {
 The `attributes` field of model definitions can be considered equivalent to
 Mongoose, but defined in JSON with extended features:
 
-```js
+```jsonc
 {
   "attributes": {
     // Shortcut for the syntax below.
@@ -129,6 +129,21 @@ Links:
 - [Validation](#validation)
 - [Access Control](#access-control)
 
+
+#### Schema Comments
+
+Schemas may be `.jsonc` which will allow comments in definitions:
+
+```jsonc
+// user.jsonc
+{
+  "attributes": {
+    // User name
+    "name": "String",
+  }
+}
+```
+
 ### Schema Extensions
 
 This module provides a number of extensions to assist schema creation outside

package/dist/cjs/index.js

@@ -7,6 +7,7 @@ var _exportNames = {
   createSchema: true,
   loadModel: true,
   loadModelDir: true,
+  loadSchema: true,
   addValidators: true,
   isEqual: true
 };
@@ -40,6 +41,12 @@ Object.defineProperty(exports, "loadModelDir", {
     return _load.loadModelDir;
   }
 });
+Object.defineProperty(exports, "loadSchema", {
+  enumerable: true,
+  get: function () {
+    return _load.loadSchema;
+  }
+});
 var _schema = require("./schema");
 var _load = require("./load");
 var _validation = require("./validation");

package/dist/cjs/load.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.loadDefinition = loadDefinition;
 exports.loadModel = loadModel;
 exports.loadModelDir = loadModelDir;
 exports.loadSchema = loadSchema;
@@ -43,55 +44,68 @@ function loadModelDir(dir) {
     if (!SCHEMA_EXTENSIONS.includes(ext)) {
       continue;
     }
-    const filepath = _path.default.join(dir, file);
-    const definition = loadDefinition(filepath);
-    const modelName = getModelName(definition, filepath);
+    const {
+      name: basename
+    } = _path.default.parse(file);
+    const definition = loadDefinition(basename, dir);
+    const modelName = getModelName(definition, basename);
     if (!_mongoose.default.models[modelName]) {
       loadModel(definition, modelName);
     }
   }
   return _mongoose.default.models;
 }
-function loadSchema(input) {
-  const definition = loadDefinition(input);
+
+/**
+ * Loads the schema from a .json or .jsonc file.
+ * @param {string} name - The model or schema name.
+ * @param {string} [dir] - The schema directory (defaults to `src/models/definitions`)
+ */
+function loadSchema(name, dir) {
+  const definition = loadDefinition(name, dir);
   return (0, _schema.createSchema)(definition);
 }
+const DEFINITION_DIR = 'src/models/definitions';
 const SCHEMA_EXTENSIONS = ['.json', '.jsonc'];
-function loadDefinition(input) {
+function loadDefinition(name, dir) {
   const {
     filepath,
     ext
-  } = resolvePath(input);
+  } = resolvePath(name, dir);
   const content = _fs.default.readFileSync(filepath, 'utf-8');
   return ext === '.jsonc' ? (0, _jsoncParser.parse)(content) : JSON.parse(content);
 }
-function resolvePath(filepath) {
-  let ext = _path.default.extname(filepath);
-  if (!ext) {
-    ext = resolveSchemaExtension(filepath);
-    filepath += ext;
+function resolvePath(name, dir = DEFINITION_DIR) {
+  if (name.includes('.')) {
+    throw new Error('Name should not include extension');
   }
+  let filename = (0, _lodash.kebabCase)(name);
+  let ext = _path.default.extname(name);
   if (!ext) {
-    throw new Error(`No .json or .jsonc file found for: ${filepath}`);
-  } else if (!SCHEMA_EXTENSIONS.includes(ext)) {
+    ext = resolveExtension(filename, dir);
+    if (ext) {
+      filename += ext;
+    } else {
+      throw new Error(`No .json or .jsonc file found for: ${name}`);
+    }
+  }
+  if (!SCHEMA_EXTENSIONS.includes(ext)) {
     throw new Error(`Schema files must be .json or .jsonc`);
   }
+  const filepath = _path.default.resolve(dir, filename);
   return {
     ext,
-    filepath: filepath
+    filepath
   };
 }
-function resolveSchemaExtension(input) {
+function resolveExtension(filename, dir) {
   for (const ext of SCHEMA_EXTENSIONS) {
-    const filepath = input + ext;
+    const filepath = _path.default.resolve(dir, filename + ext);
     if (_fs.default.existsSync(filepath)) {
       return ext;
     }
   }
 }
-function getModelName(definition, filepath) {
-  const {
-    name: filename
-  } = _path.default.parse(filepath);
-  return definition.modelName || (0, _lodash.startCase)(filename).replace(/\s/g, '');
+function getModelName(definition, basename) {
+  return definition.modelName || (0, _lodash.startCase)(basename).replace(/\s/g, '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/index.js

@@ -1,5 +1,5 @@
 export { createSchema } from './schema';
-export { loadModel, loadModelDir } from './load';
+export { loadModel, loadModelDir, loadSchema } from './load';
 export { addValidators } from './validation';
 export { isEqual } from './utils';
 export * from './testing';

package/src/load.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 
 import { parse as parseWithComments } from 'jsonc-parser';
+import { kebabCase } from 'lodash';
 import { startCase } from 'lodash';
 import mongoose from 'mongoose';
 
@@ -39,9 +40,9 @@ export function loadModelDir(dir) {
       continue;
     }
 
-    const filepath = path.join(dir, file);
-    const definition = loadDefinition(filepath);
-    const modelName = getModelName(definition, filepath);
+    const { name: basename } = path.parse(file);
+    const definition = loadDefinition(basename, dir);
+    const modelName = getModelName(definition, basename);
 
     if (!mongoose.models[modelName]) {
       loadModel(definition, modelName);
@@ -50,49 +51,64 @@ export function loadModelDir(dir) {
   return mongoose.models;
 }
 
-export function loadSchema(input) {
-  const definition = loadDefinition(input);
+/**
+ * Loads the schema from a .json or .jsonc file.
+ * @param {string} name - The model or schema name.
+ * @param {string} [dir] - The schema directory (defaults to `src/models/definitions`)
+ */
+export function loadSchema(name, dir) {
+  const definition = loadDefinition(name, dir);
   return createSchema(definition);
 }
 
+const DEFINITION_DIR = 'src/models/definitions';
 const SCHEMA_EXTENSIONS = ['.json', '.jsonc'];
 
-function loadDefinition(input) {
-  const { filepath, ext } = resolvePath(input);
+export function loadDefinition(name, dir) {
+  const { filepath, ext } = resolvePath(name, dir);
   const content = fs.readFileSync(filepath, 'utf-8');
   return ext === '.jsonc' ? parseWithComments(content) : JSON.parse(content);
 }
 
-function resolvePath(filepath) {
-  let ext = path.extname(filepath);
+function resolvePath(name, dir = DEFINITION_DIR) {
+  if (name.includes('.')) {
+    throw new Error('Name should not include extension');
+  }
+
+  let filename = kebabCase(name);
+  let ext = path.extname(name);
 
   if (!ext) {
-    ext = resolveSchemaExtension(filepath);
-    filepath += ext;
+    ext = resolveExtension(filename, dir);
+
+    if (ext) {
+      filename += ext;
+    } else {
+      throw new Error(`No .json or .jsonc file found for: ${name}`);
+    }
   }
 
-  if (!ext) {
-    throw new Error(`No .json or .jsonc file found for: ${filepath}`);
-  } else if (!SCHEMA_EXTENSIONS.includes(ext)) {
+  if (!SCHEMA_EXTENSIONS.includes(ext)) {
     throw new Error(`Schema files must be .json or .jsonc`);
   }
 
+  const filepath = path.resolve(dir, filename);
+
   return {
     ext,
-    filepath: filepath,
+    filepath,
   };
 }
 
-function resolveSchemaExtension(input) {
+function resolveExtension(filename, dir) {
   for (const ext of SCHEMA_EXTENSIONS) {
-    const filepath = input + ext;
+    const filepath = path.resolve(dir, filename + ext);
     if (fs.existsSync(filepath)) {
       return ext;
     }
   }
 }
 
-function getModelName(definition, filepath) {
-  const { name: filename } = path.parse(filepath);
-  return definition.modelName || startCase(filename).replace(/\s/g, '');
+function getModelName(definition, basename) {
+  return definition.modelName || startCase(basename).replace(/\s/g, '');
 }

package/types/generated/index.d.ts

@@ -3,5 +3,5 @@ export { addValidators } from "./validation";
 export { isEqual } from "./utils";
 export * from "./testing";
 export * from "./errors";
-export { loadModel, loadModelDir } from "./load";
+export { loadModel, loadModelDir, loadSchema } from "./load";
 //# sourceMappingURL=index.d.ts.map

package/types/generated/load.d.ts

@@ -11,7 +11,12 @@ export function loadModel(definition: object, name: string): any;
  * @param {string} dir
  */
 export function loadModelDir(dir: string): mongoose.Models;
-export function loadSchema(input: any): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, mongoose.DefaultSchemaOptions, {
+/**
+ * Loads the schema from a .json or .jsonc file.
+ * @param {string} name - The model or schema name.
+ * @param {string} [dir] - The schema directory (defaults to `src/models/definitions`)
+ */
+export function loadSchema(name: string, dir?: string): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, any, mongoose.DefaultSchemaOptions, {
     [x: number]: unknown;
     [x: symbol]: unknown;
     [x: string]: unknown;
@@ -28,5 +33,6 @@ export function loadSchema(input: any): mongoose.Schema<any, mongoose.Model<any,
 }> & {
     __v: number;
 }>;
+export function loadDefinition(name: any, dir: any): any;
 import mongoose from 'mongoose';
 //# sourceMappingURL=load.d.ts.map

package/types/generated/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/load.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,kCAFW,MAAM,mBAoBhB;AAED;;;;;;;;;;;;;;;;GAGC;qBAlDoB,UAAU"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/load.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,kCAFW,MAAM,mBAoBhB;AAED;;;;GAIG;AACH,iCAHW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;GAKhB;AAKD,yDAIC;qBAhEoB,UAAU"}