lamix 4.2.6

package/examples/PostController.md

@@ -0,0 +1,93 @@
+const Post = require('../app/models/Post');
+const User = require('../app/models/User');
+
+class PostController {
+  async index(req, res) {
+    try {
+      const { page, perPage } = req.query;
+      const result = await Post.query().paginate(page || 1, perPage || 10);
+      return res.render('posts/index', { posts: result.data, page: result.page, lastPage: result.lastPage });
+    } catch (err) {
+      console.error(err);
+      return res.status(500).send('Error listing posts');
+    }
+  }
+
+  async show(req, res) {
+    try {
+      const { id } = req.params;
+      const post = await Post.query().with('user').where('id', id).first();
+      if (!post) return res.status(404).send('Post not found');
+      return res.render('posts/show', { post });
+    } catch (err) {
+      console.error(err);
+      return res.status(500).send('Error fetching post');
+    }
+  }
+
+  async create(req, res) {
+    const users = await User.query().get();
+    return res.render('posts/create', { users });
+  }
+
+  async store(req, res) {
+    try {
+      const attrs = req.body;
+      const post = await Post.create(attrs);
+      return res.redirect(`/posts/${post.id}`);
+    } catch (err) {
+      console.error(err);
+      return res.status(400).send('Error creating post');
+    }
+  }
+
+  async edit(req, res) {
+    const { id } = req.params;
+    const post = await Post.find(id);
+    if (!post) return res.status(404).send('Post not found');
+    const users = await User.query().get();
+    return res.render('posts/edit', { post, users });
+  }
+
+  async update(req, res) {
+    try {
+      const { id } = req.params;
+      const post = await Post.find(id);
+      if (!post) return res.status(404).send('Post not found');
+      await post.fill(req.body);
+      await post.save();
+      return res.redirect(`/posts/${post.id}`);
+    } catch (err) {
+      console.error(err);
+      return res.status(400).send('Error updating post');
+    }
+  }
+
+  async destroy(req, res) {
+    try {
+      const { id } = req.params;
+      const post = await Post.find(id);
+      if (!post) return res.status(404).send('Post not found');
+      await post.delete();
+      return res.redirect('/posts');
+    } catch (err) {
+      console.error(err);
+      return res.status(500).send('Error deleting post');
+    }
+  }
+
+  async restore(req, res) {
+    try {
+      const { id } = req.params;
+      const p = await Post.withTrashed().where('id', id).first();
+      if (!p) return res.status(404).send('Post not found');
+      await p.restore();
+      return res.redirect(`/posts/${p.id}`);
+    } catch (err) {
+      console.error(err);
+      return res.status(500).send('Error restoring post');
+    }
+  }
+}
+
+module.exports = new PostController();

package/examples/Query Builder.md

@@ -0,0 +1,55 @@
+const qb = User.query();
+
+// Select
+const names = await User.query().select('id', 'name').get();
+
+// Aggregates
+const cnt = await User.query().count();
+const sumId = await User.query().sum('id');
+const avgId = await User.query().avg('id');
+const minId = await User.query().min('id');
+const maxId = await User.query().max('id');
+
+// Status column example
+const users = await User.query().where('status', true).get();
+
+// Ordering
+const usersorderbyid = await User.query()
+  .where('status', true)
+  .orderBy('id', 'desc')
+  .get();
+
+// Pluck
+const emails = await User.query().pluck('email');
+
+// Pagination
+const page1 = await User.query().paginate(1, 10);
+
+// Where In
+const usersIn = await User.query().whereIn('id', [1, 2, 3]).get();
+
+// Null checks
+const withNull = await User.query().whereNull('deleted_at').get();
+const notNull = await User.query().whereNotNull('deleted_at').get();
+
+// Between
+const inRange = await User.query().whereBetween('id', [10, 20]).get();
+
+// Grouping & having
+const grouped = await User.query()
+  .select('user_id', 'COUNT(*) as cnt')
+  .groupBy('user_id')
+  .having('cnt', '>', 1)
+  .get();
+
+// Joins
+const withPosts = await User.query()
+  .select('users.*', 'posts.title as post_title')
+  .join('INNER', 'posts', 'users.id', '=', 'posts.user_id')
+  .get();
+
+// Locking
+await User.query().where('id', 5).forUpdate().get();
+
+// Raw queries
+const rows = await User.raw('SELECT * FROM users WHERE id = ?', [5]);

package/examples/Relations.md

@@ -0,0 +1,16 @@
+// One-to-many
+const user = await User.find(1);
+const posts = await user.posts().get();
+
+// Eager loading
+const usersWithPosts = await User.query().with('posts').get();
+
+// Many-to-many
+const user = await User.find(2);
+
+const roles = await user.roles().get();
+await user.roles().attach(5);
+await user.roles().detach(3);
+
+// Eager load multiple relations
+const users = await User.query().with(['roles', 'posts', 'comments']).get();

package/examples/Role.md

@@ -0,0 +1,26 @@
+const { BaseModel } = require('lamix');
+
+class Role extends BaseModel {
+  static table = 'roles';
+  static primaryKey = 'id';
+  static timestamps = false;
+  static softDeletes = false;// Optional if you don't need it
+  static fillable = ['name'];
+  static rules = {
+    name: 'required|string'
+  };
+
+  users() {
+    const User = require('./User');
+    return this.belongsToMany(
+      User,
+      'user_roles',
+      'role_id',
+      'user_id',
+      'id',
+      'id'
+    ).onDelete('detach');
+  }
+}
+
+module.exports = Role;

package/examples/RoleController.md

@@ -0,0 +1,65 @@
+const Role = require('../app/models/Role');
+
+class RoleController {
+  async index(req, res) {
+    const roles = await Role.query().get();
+    return res.render('roles/index', { roles });
+  }
+
+  async show(req, res) {
+    const { id } = req.params;
+    const role = await Role.find(id);
+    if (!role) return res.status(404).send('Role not found');
+    return res.render('roles/show', { role });
+  }
+
+  async create(req, res) {
+    return res.render('roles/create');
+  }
+
+  async store(req, res) {
+    try {
+      const r = await Role.create(req.body);
+      return res.redirect(`/roles/${r.id}`);
+    } catch (err) {
+      console.error(err);
+      return res.status(400).send('Error creating role');
+    }
+  }
+
+  async edit(req, res) {
+    const { id } = req.params;
+    const role = await Role.find(id);
+    if (!role) return res.status(404).send('Role not found');
+    return res.render('roles/edit', { role });
+  }
+
+  async update(req, res) {
+    try {
+      const { id } = req.params;
+      const role = await Role.find(id);
+      if (!role) return res.status(404).send('Role not found');
+      await role.fill(req.body);
+      await role.save();
+      return res.redirect(`/roles/${role.id}`);
+    } catch (err) {
+      console.error(err);
+      return res.status(400).send('Error updating role');
+    }
+  }
+
+  async destroy(req, res) {
+    try {
+      const { id } = req.params;
+      const role = await Role.find(id);
+      if (!role) return res.status(404).send('Role not found');
+      await role.delete();
+      return res.redirect('/roles');
+    } catch (err) {
+      console.error(err);
+      return res.status(500).send('Error deleting role');
+    }
+  }
+}
+
+module.exports = new RoleController();

package/examples/Usages.md

@@ -0,0 +1,132 @@
+//Basic CRUD & Query
+
+const User = require('./models/User');
+
+// Create new user
+const user = await User.create({ name: 'Alice', email: 'alice@example.com', password: 'secret' });
+
+// Fill & save (update)
+user.name = 'Alice Smith';  // you can also use user.fill({ name: 'Alice Smith' })
+await user.save();
+
+// Find by primary key
+const user1 = await User.find(1);
+const user2 = await User.findOrFail(param.id);
+
+// Query with where
+const someUsers = await User.where('email', 'alice@example.com').get();
+
+// First match
+const firstUser = await User.where('name', 'Alice').first();
+const firstOrFail = await User.where('name', 'Alice').firstOrFail();
+
+const user = await User.findBy('email', 'jane@example.com');
+// by default Field password is Auto encrypted when creating
+const isValid = await user.checkPassword('user_input_password');
+// Delete (soft delete if enabled)
+await user.delete();
+
+// destroy (delete Multiple ids)
+await user.destroy();
+
+// update (by default)
+await user.update({ body });
+or
+// update
+await user.fill({ body });
+await user.save();
+
+// Restore (if softDeletes enabled)
+await user.restore();
+
+// List all (excluding trashed, by default)
+const allUsers = await User.all();
+
+// Query including soft-deleted (trashed) records
+const withTrashed = await User.withTrashed().where('id', 1).first();
+
+//QueryBuilder Advanced Features
+
+const qb = User.query();
+
+// Select specific columns
+const names = await User.query().select('id', 'name').get();
+
+// Aggregates
+const cnt = await User.query().count();          // count(*)
+const sumId = await User.query().sum('id');
+const avgId = await User.query().avg('id');
+const minId = await User.query().min('id');
+const maxId = await User.query().max('id');
+
+// status a column (returns status of boolean values)
+const usersAll = await User.all();
+const users = await User.query().where('status', true).get();
+const usersorderbyid = await User.query().where('status', true).orderBy('id', 'desc').get();
+const usersorderbycreateAt = await User.query().where('status', true).orderBy('created_at', 'desc').get();
+
+// Pluck a column (returns array of values)
+const Pluckemails = await User.query().pluck('email');
+
+// Pagination
+const page1 = await User.query().paginate(1, 10);
+// page1 = { total, perPage, page, lastPage, data: [users...] }
+
+// Where In
+const usersIn = await User.query().whereIn('id', [1, 2, 3]).get();
+
+// Where Null / Not Null
+const withNull = await User.query().whereNull('deleted_at').get();
+const notNull = await User.query().whereNotNull('deleted_at').get();
+
+// Where Between
+const inRange = await User.query().whereBetween('id', [10, 20]).get();
+
+// Ordering, grouping, having
+const grouped = await User.query()
+  .select('user_id', 'COUNT(*) as cnt')
+  .groupBy('user_id')
+  .having('cnt', '>', 1)
+  .get();
+
+// Joins
+const withPosts = await User.query()
+  .select('users.*', 'posts.title as post_title')
+  .join('INNER', 'posts', 'users.id', '=', 'posts.user_id')
+  .get();
+
+// Using “forUpdate” (locking)
+await User.query().where('id', 5).forUpdate().get();
+
+// Raw queries
+const rows = await User.raw('SELECT * FROM users WHERE id = ?', [5]);
+
+// Caching
+const cachedRows = await User.raw('SELECT * FROM users', []).then(rows => rows);
+const cached = await DB.cached('SELECT * FROM users WHERE id = ?', [5], 60000);
+
+//You can use relations:
+
+const user = await User.find(1);
+const posts = await user.posts().get();  // all posts for the user
+
+// Eager load in a query with Relations:
+const usersWithPosts = await User.query().with('posts').get();
+// Each user will have a `posts` field with array of post models.
+
+// Many-to-many example
+// Suppose you have an intermediate pivot table user_roles (user_id, role_id)
+// and models User and Role, with pivot user_roles.
+//
+
+// Then:
+const user = await User.find(2);
+const roles = await user.roles().get();
+
+// Eager load with Relations:
+const usersWithRoles = await User.query().with('roles').get();
+
+// Eager load with Many to Many Relations:
+const usersWith_Roles_posts_comments = await User.query().with(['roles', 'posts', 'comments' ]).get();
+//OR with Many to Many Relations:
+const users_With_Roles_posts_comments = await User.with(['roles', 'posts', 'comments' ]).get();

package/examples/User.md

@@ -0,0 +1,40 @@
+// models/User.js
+const { BaseModel} = require('lamix');
+
+class User extends BaseModel {
+  static table = 'users';
+  static primaryKey = 'id';
+  static timestamps = true;
+  static softDeletes = true;// Optional if you don't need it
+  static fillable = ['name', 'email', 'password'];// password is Auto encrypted when creating.
+  static rules = {
+    name: 'required|string',
+    email: 'required|email|unique:users,email',
+    password: 'required|string|min:6',
+    phone: 'nullable|phone',
+    status: 'nullable|boolean'
+  };
+
+  profile() {
+    return this.hasOne(Profile).onDelete('restrict');
+  }
+
+  
+  // Many-to-many: User ↔ Role via pivot user_roles (user_id, role_id)
+  roles() {
+    const Role = require('./Role');
+    return this.belongsToMany(
+      Role,
+      'user_roles',
+      'user_id',
+      'role_id'
+    ).onDelete('detach');
+  }
+
+  // One-to-many: User -> Post
+  posts() {
+    return this.hasMany(require('./Post'), 'user_id', 'id').onDelete('cascade');
+  }
+}
+
+module.exports = User;

package/examples/UserController.md

@@ -0,0 +1,98 @@
+// controllers/UserController.js
+const User = require('Model-User');
+const { ValidationError } = require('lamix');
+
+class UserController {
+  // GET /users
+  async index(req, res) {
+    try {
+      const users = await User.query().get();
+      return res.json(users);
+    } catch (err) {
+      return res.status(500).json({ error: 'Failed to fetch users.' });
+    }
+  }
+
+  // GET /users/:id
+  async show(req, res) {
+    try {
+      const user = await User.find(req.params.id);
+      if (!user) return res.status(404).json({ error: 'User not found.' });
+      return res.json(user);
+    } catch (err) {
+      return res.status(500).json({ error: 'Failed to fetch user.' });
+    }
+  }
+
+  // POST /users
+  static async store(req, res) {
+    const input = {
+      name: req.body.name,
+      email: req.body.email,
+      password: req.body.password,
+      phone: req.body.phone,
+      status: req.body.status,
+    };
+
+    try {
+      await User.create({
+        name: input.name,
+        email: input.email,
+        password: input.password,
+        phone: input.phone,
+        status: input.status === 'true',
+      });
+
+      req.flash('success', 'User created successfully!');
+      res.redirect('/users');
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        return res.status(422).json(e.errors);
+      }
+      throw e;
+    }
+  }
+
+  // PUT /users/:id
+  async update(req, res) {
+    try {
+      const user = await User.find(req.params.id);
+      if (!user) return res.status(404).json({ error: 'User not found.' });
+
+      await user.fill(req.body);
+      await user.save();
+
+      return res.json(user);
+    } catch (err) {
+      return res.status(400).json({ error: 'Failed to update user.' });
+    }
+  }
+
+  // DELETE /users/:id
+  async destroy(req, res) {
+    try {
+      const user = await User.find(req.params.id);
+      if (!user) return res.status(404).json({ error: 'User not found.' });
+
+      await user.delete();
+      return res.status(204).send();
+    } catch (err) {
+      return res.status(500).json({ error: 'Failed to delete user.' });
+    }
+  }
+
+  // POST /users/:id/restore
+  async restore(req, res) {
+    try {
+      const user = await User.withTrashed().where('id', req.params.id).first();
+      if (!user) return res.status(404).json({ error: 'User not found.' });
+
+      await user.restore();
+      return res.json(user);
+    } catch (err) {
+      return res.status(500).json({ error: 'Failed to restore user.' });
+    }
+  }
+}
+
+module.exports = new UserController();