@bedrockio/model 0.20.2 → 0.21.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.21.0
+
+- Allow comments in schemas with .jsonc.
+
 ## 0.20.2
 
 - Fixed `_id: false` on validation schemas.

package/dist/cjs/load.js

@@ -5,8 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.loadModel = loadModel;
 exports.loadModelDir = loadModelDir;
+exports.loadSchema = loadSchema;
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
+var _jsoncParser = require("jsonc-parser");
 var _lodash = require("lodash");
 var _mongoose = _interopRequireDefault(require("mongoose"));
 var _schema = require("./schema");
@@ -32,21 +34,64 @@ function loadModel(definition, name) {
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.
- * @param {string} dirPath
+ * @param {string} dir
  */
-function loadModelDir(dirPath) {
-  const files = _fs.default.readdirSync(dirPath);
+function loadModelDir(dir) {
+  const files = _fs.default.readdirSync(dir);
   for (const file of files) {
-    const basename = _path.default.basename(file, '.json');
-    if (file.match(/\.json$/)) {
-      const filePath = _path.default.join(dirPath, file);
-      const data = _fs.default.readFileSync(filePath, 'utf-8');
-      const definition = JSON.parse(data);
-      const modelName = definition.modelName || (0, _lodash.startCase)(basename).replace(/\s/g, '');
-      if (!_mongoose.default.models[modelName]) {
-        loadModel(definition, modelName);
-      }
+    const ext = _path.default.extname(file);
+    if (!SCHEMA_EXTENSIONS.includes(ext)) {
+      continue;
+    }
+    const filepath = _path.default.join(dir, file);
+    const definition = loadDefinition(filepath);
+    const modelName = getModelName(definition, filepath);
+    if (!_mongoose.default.models[modelName]) {
+      loadModel(definition, modelName);
     }
   }
   return _mongoose.default.models;
+}
+function loadSchema(input) {
+  const definition = loadDefinition(input);
+  return (0, _schema.createSchema)(definition);
+}
+const SCHEMA_EXTENSIONS = ['.json', '.jsonc'];
+function loadDefinition(input) {
+  const {
+    filepath,
+    ext
+  } = resolvePath(input);
+  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;
+  }
+  if (!ext) {
+    throw new Error(`No .json or .jsonc file found for: ${filepath}`);
+  } else if (!SCHEMA_EXTENSIONS.includes(ext)) {
+    throw new Error(`Schema files must be .json or .jsonc`);
+  }
+  return {
+    ext,
+    filepath: filepath
+  };
+}
+function resolveSchemaExtension(input) {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const filepath = input + 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, '');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.20.2",
+  "version": "0.21.0",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -27,6 +27,7 @@
   },
   "dependencies": {
     "@bedrockio/logger": "^1.1.1",
+    "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21"
   },
   "peerDependencies": {

package/src/load.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 
+import { parse as parseWithComments } from 'jsonc-parser';
 import { startCase } from 'lodash';
 import mongoose from 'mongoose';
 
@@ -27,22 +28,71 @@ export function loadModel(definition, name) {
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.
- * @param {string} dirPath
+ * @param {string} dir
  */
-export function loadModelDir(dirPath) {
-  const files = fs.readdirSync(dirPath);
+export function loadModelDir(dir) {
+  const files = fs.readdirSync(dir);
   for (const file of files) {
-    const basename = path.basename(file, '.json');
-    if (file.match(/\.json$/)) {
-      const filePath = path.join(dirPath, file);
-      const data = fs.readFileSync(filePath, 'utf-8');
-      const definition = JSON.parse(data);
-      const modelName =
-        definition.modelName || startCase(basename).replace(/\s/g, '');
-      if (!mongoose.models[modelName]) {
-        loadModel(definition, modelName);
-      }
+    const ext = path.extname(file);
+
+    if (!SCHEMA_EXTENSIONS.includes(ext)) {
+      continue;
+    }
+
+    const filepath = path.join(dir, file);
+    const definition = loadDefinition(filepath);
+    const modelName = getModelName(definition, filepath);
+
+    if (!mongoose.models[modelName]) {
+      loadModel(definition, modelName);
     }
   }
   return mongoose.models;
 }
+
+export function loadSchema(input) {
+  const definition = loadDefinition(input);
+  return createSchema(definition);
+}
+
+const SCHEMA_EXTENSIONS = ['.json', '.jsonc'];
+
+function loadDefinition(input) {
+  const { filepath, ext } = resolvePath(input);
+  const content = fs.readFileSync(filepath, 'utf-8');
+  return ext === '.jsonc' ? parseWithComments(content) : JSON.parse(content);
+}
+
+function resolvePath(filepath) {
+  let ext = path.extname(filepath);
+
+  if (!ext) {
+    ext = resolveSchemaExtension(filepath);
+    filepath += ext;
+  }
+
+  if (!ext) {
+    throw new Error(`No .json or .jsonc file found for: ${filepath}`);
+  } else if (!SCHEMA_EXTENSIONS.includes(ext)) {
+    throw new Error(`Schema files must be .json or .jsonc`);
+  }
+
+  return {
+    ext,
+    filepath: filepath,
+  };
+}
+
+function resolveSchemaExtension(input) {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const filepath = input + 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, '');
+}

package/types/generated/load.d.ts

@@ -8,8 +8,25 @@ export function loadModel(definition: object, name: string): any;
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.
- * @param {string} dirPath
+ * @param {string} dir
  */
-export function loadModelDir(dirPath: string): mongoose.Models;
+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, {
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+    [x: string]: unknown;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+    [x: string]: unknown;
+}>, any, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+    [x: string]: unknown;
+}> & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}>;
 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":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB;qBA3CoB,UAAU"}
+{"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"}