@vulkano/core 1.20.1 → 1.22.0

package/examples/models/Example.js

@@ -0,0 +1,238 @@
+/* global Example */
+
+/**
+ * Example.js
+ */
+
+// This is an example for a simple model that provides CRUD operations.
+// Provide a flexible way to implement business logic in the model, which is a good practice
+// to keep the controller thin and focused on handling requests and responses.
+
+module.exports = {
+
+  /**
+   * Fields
+   */
+  attributes: {
+    name: {
+      type: String,
+      required: true
+    },
+    age: {
+      type: Number,
+      required: false,
+      validate: {
+        validator: (value) => {
+          const isValid = (value >= 21) ? true : false;
+          return isValid;
+        },
+        message: 'Invalid Age: Must be +21.',
+      }
+    }
+    // the fields:
+    // active, createdAt, updatedAt
+    // was created automatically
+  },
+
+  // Custom Index
+  indexes: [
+    {
+      name: 'text'
+    }
+  ],
+
+  /**
+   * Method to get all records by page
+   *
+   * @param {Object} props (page, perPage, search, sort)
+   * @returns {Promise}
+   */
+  getAll(props) {
+
+    // Props to Query
+    const defaultProps = {
+      sort: 'createdAt|DESC',
+      searchBy: ['name'],
+      fields: ['name', 'age', 'active', 'createdAt', 'updatedAt'],
+      filter: {
+        active: true
+      },
+    };
+
+    // Populate
+    const populate = [];
+
+    // Query to Run
+    const query = Paginate.serializeQuery(defaultProps, props);
+
+    // Pagination
+    return Paginate.get(Example, query, populate);
+
+  },
+
+  /**
+   * Method to get a record by id
+   *
+   * @param {ObjectID} id
+   * @returns {Promise}
+   */
+  getExample(_id) {
+
+    // This is to prevent error while run the findOne
+    if (!(/^[a-fA-F0-9]{24}$/).test(_id)) {
+      return VSError.reject('Invalid ID. Record not found', 404);
+    }
+
+    return Example.findOne({ _id })
+      .then( (r) => {
+
+        if (!r) {
+          return VSError.notFound();
+        }
+
+        return r.toObject({ transform: true });
+
+      });
+
+  },
+
+  /**
+   * Method to create a new record
+   * @param {Promise} data
+   */
+  create(data) {
+
+    const obj = new Example(data);
+    return obj.save();
+
+  },
+
+  /**
+   * Method to update a record
+   * @param {ObjectID} id
+   * @param {Object} data
+   * @returns {Promise}
+   */
+  update(_id, data) {
+
+    return Example.getExample(_id)
+      .then( (record) => {
+
+        // Merge current info with incoming values
+        const merged = { ...record, ...data };
+
+        return Example
+          .findOneAndUpdate({ _id }, merged, { new: true })
+          .then( (r) => {
+
+            const tmp = r.toObject({ transform: true });
+            return tmp;
+
+          });
+
+      });
+
+  },
+
+  /**
+   * Method to delete a record
+   * @param {ObjectID} id
+   * @returns {Promise}
+   */
+  delete(id) {
+
+    // Soft delete
+    return this.update(id, { active: false });
+
+  },
+
+  /**
+   * Before validate callback — runs before beforeSave, as part of obj.save()
+   * (create() above). Does NOT run for update()/delete(): Mongoose's update
+   * validators (runValidators) validate each changed path directly and never
+   * go through this callback, even when a validator rejects the value.
+   * @param {Callback} cb
+   */
+  beforeValidate(cb) {
+
+    console.log('Running callback before validate');
+
+    // All good!
+    cb();
+
+  },
+
+  /**
+   * Callback after validate
+   * @param {Callback} cb
+   */
+  afterValidate(cb) {
+
+    console.log('Running callback after validate');
+
+    // All good!
+    cb();
+
+  },
+
+  /**
+   * Before save callback
+   * @param {Callback} cb
+   */
+  beforeSave(cb) {
+
+    const doc = this;
+
+    console.log('Running callback before save');
+    console.log(doc);
+
+    // All good!
+    cb();
+
+  },
+
+  /**
+   * Callback after save
+   * @param {Callback} cb
+   */
+  afterSave(doc, cb) {
+
+    console.log('Running callback after save');
+    console.log(doc);
+
+    // All good!
+    cb();
+
+  },
+
+  /**
+   * Before findOneAndUpdate callback — runs on update() and delete() above,
+   * since both call Example.findOneAndUpdate() directly. `this` is the Query,
+   * not the document.
+   * @param {Callback} cb
+   */
+  beforeFindOneAndUpdate(cb) {
+
+    console.log('Running callback before findOneAndUpdate');
+
+    // All good!
+    cb();
+
+  },
+
+  /**
+   * Callback after findOneAndUpdate
+   * @param {Object} doc Updated document
+   * @param {Callback} cb
+   */
+  afterFindOneAndUpdate(doc, cb) {
+
+    console.log('Running callback after findOneAndUpdate');
+    console.log(doc);
+
+    // All good!
+    cb();
+
+  },
+
+};

package/examples/models/ExampleWithScaffold.js

@@ -0,0 +1,51 @@
+/**
+ * ExampleWithScaffold.js
+ */
+
+// This is an example for a simple model that provides CRUD operations with a scaffold.
+// Provide a flexible way to implement business logic in the model, which is a good practice
+// to keep the controller thin and focused on handling requests and responses.
+
+// Scaffold (Model name: ExampleWithScaffold) - Allowed Methods:
+// ExampleWidthScaffold.getAllExampleWidthScaffold(props) { page, perPage, search, sort }
+// ExampleWidthScaffold.getAll(props) (alias to getAllModelName)
+// ExampleWidthScaffold.create(payload) { name, age }
+// ExampleWidthScaffold.getByField(email, 'email') (alias)
+// ExampleWidthScaffold.getExampleWidthScaffold(id)
+// ExampleWidthScaffold.update(id, payload)
+// ExampleWidthScaffold.delete(id)
+
+module.exports = {
+
+  /**
+   * Fillable fields for the update method
+   * to prevent update of non-allowed fields like createdAt, updatedAt, etc.
+   * @type Array
+   */
+  fillable: ['name', 'age'],
+
+  /**
+   * Fields
+   */
+  attributes: {
+    name: {
+      type: String,
+      required: true
+    },
+    age: {
+      type: Number,
+      required: false,
+      validate: {
+        validator: (value) => {
+          const isValid = (value >= 21) ? true : false;
+          return isValid;
+        },
+        message: 'Invalid Age: Must be +21.',
+      }
+    },
+    // the fields:
+    // active, createdAt, updatedAt
+    // was created automatically
+  }
+
+};

package/examples/routes.js

@@ -0,0 +1,55 @@
+/* global app */
+
+/**
+ * Alias Route Mappings
+ *
+ * Your routes map URLs to views and controllers.
+ *
+ * Notes: Vulkano automatically matches the URL to a controller
+ * and HTTP method (get, post, put, delete) ;)
+ *
+ * Example:
+ * - GET /users/ -> File: UsersController, Method: 'get': (req, res) => {}
+ * - GET /users/123 -> File: UsersController, Method: 'get :id': (req, res) => {}
+ * - POST /users/ -> File: UsersController, Method: 'post': (req, res) => {}
+ * - PUT /users/123 -> File: UsersController, Method: 'put :id': (req, res) => {}
+ * - DELETE /users/123 -> File: UsersController, Method: 'delete :id': (req, res) => {}
+ *
+ * With nested folders, the same rules apply:
+ * - GET /api/users/123 -> Folder: api -> File: UsersController, Method: 'get :id': (req, res) => {}
+ *
+ * But you can write your own routes manually :P
+ *
+ */
+
+module.exports = {
+
+  // Routes as string - Simple and easy to use
+  '/about-me': 'AboutController.get',
+
+  // Catch-all for React/Vue Router (SPA)
+  '/admin*': 'AdminController.get',
+
+  // Routes as definition - Most flexible
+  '/test': (req, res) => {
+    res.json({ message: 'Hello, world!' });
+  },
+
+  // Routes as method - More Advanced
+  custom() {
+
+    app.vulkano.get('/test', (req, res) => {
+      res.json({ hello: 'world' });
+    });
+
+    app.vulkano.get('/test2', (req, res) => {
+      res.json({ hello: 'world2' });
+    });
+
+    app.vulkano.get('/test3', (req, res) => {
+      res.json({ hello: 'world3' });
+    });
+
+  }
+
+};

package/examples/views/_shared/templates/default.html

@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html lang="en">
+  <head>
+    <title>{{ title }}</title>
+    <meta charset=UTF-8 >
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="shortcut icon" type="image/png" href="/favicon.png?v={{ app.pkg.version }}" />
+
+    {{ vite({ entry: 'app', type: 'style' }) | safe }}
+
+  </head>
+  <body>
+
+    <div id="app">{% block content %}{% endblock %}</div>
+
+    {{ vite({ entry: 'app', type: 'script' }) | safe }}
+
+  </body>
+</html>

package/examples/views/index.html

@@ -0,0 +1,7 @@
+{% extends "_shared/templates/default.html" %}
+
+{% block content %}
+
+Your content goes here.
+
+{% endblock %}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vulkano/core",
-  "version": "1.20.1",
+  "version": "1.22.0",
   "description": "A MVC framework using Express 4",
   "license": "MIT",
   "author": "Vulkano Team",

package/pnpm-workspace.yaml

@@ -4,10 +4,16 @@ allowBuilds:
 catalog:
   vite: npm:@voidzero-dev/vite-plus-core@latest
   vitest: npm:@voidzero-dev/vite-plus-test@latest
-  vite-plus: latest
+  vite-plus: ^0.2.4
 overrides:
   vite: "catalog:"
   vitest: "catalog:"
+  # Safety floor for the real "vite" package pnpm auto-installs to satisfy
+  # @voidzero-dev/vite-plus-test / @vitest/mocker's peerDependency (they
+  # require actual vite, not the vite-plus-core alias). Keeps it above the
+  # server.fs.deny bypass (GHSA-v6wh-96g9-6wx3), fixed in 8.0.16.
+  "@vitest/mocker>vite": ^8.1.4
+  "@voidzero-dev/vite-plus-test>vite": ^8.1.4
 peerDependencyRules:
   allowAny:
     - vite