@paralect/hive 0.1.49 → 0.1.50-alpha.0

package/cli/hive.js

@@ -7,9 +7,36 @@ const inquirer = require('inquirer');
 const mergeDirs = require('./helpers/mergeDirs');
 const execCommand = require('./helpers/execCommand');
 const downloadDirectory = require('./helpers/downloadDirectory');
+const { isDockerInstalled, startMongo, startRedis } = require('./helpers/docker');
+const { ensureEnvConfig, hashCode } = require('./helpers/envCheck');
+const { findAvailablePort } = require('./helpers/findPort');
 const axios = require('axios');
-const tsx = require('tsx/cjs/api');
 const fs = require('fs');
+const { spawn } = require('child_process');
+
+const hivePackage = require('../package.json');
+
+let appPackage = {
+  "name": "my-hive-app",
+  "version": "1.0.0",
+  "description": "Hive App",
+  "main": "src/app.js",
+  "scripts": {
+    "prepare": "hive prepare ./src",
+    "dev": "hive prepare ./src && HIVE_SRC=$PWD/src npm -C .hive run dev",
+    "start": "hive prepare ./src && HIVE_SRC=$PWD/src npm -C .hive run start",
+    "deploy-local": "hive build-local && hive deploy"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@paralect/hive": hivePackage.version,
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.4"
+  }
+}
 
 program
   .command('init [projectName]')
@@ -43,18 +70,15 @@ program
         path.join(projectDir, 'package.json'),
         JSON.stringify({
           name,
-          version: '1.0.0',
-          scripts: {
-            dev: 'hive run ./src',
-            start: 'hive run ./src'
-          },
-          dependencies: {}
+          ...appPackage
+
         }, null, 2)
       );
 
+      const redisDb = hashCode(name) % 16;
       fs.writeFileSync(
         path.join(projectDir, '.env'),
-        `MONGO_URI=mongodb://localhost:27017/${name}\nPORT=3001\nNODE_ENV=development\n`
+        `MONGODB_URI=mongodb://localhost:27017/${name}\nREDIS_URI=redis://localhost:6379/${redisDb}\nPORT=3001\nNODE_ENV=development\n`
       );
 
       fs.writeFileSync(
@@ -76,18 +100,62 @@ program
     }
   });
 
+program
+  .command('infra-docker')
+  .description('Start shared MongoDB and Redis containers for local development')
+  .action(async () => {
+    try {
+      if (!isDockerInstalled()) {
+        console.error('Docker is not installed or not running. Please install Docker first.');
+        process.exit(1);
+      }
+
+      console.log('\nStarting Hive infrastructure...\n');
+      
+      await startMongo();
+      await startRedis();
+
+      console.log('\n✅ Infrastructure ready!\n');
+      console.log('Connection URIs:');
+      console.log('  MongoDB: mongodb://localhost:27017/<your-db-name>');
+      console.log('  Redis:   redis://localhost:6379/<db-number>\n');
+      console.log('These containers are shared across all Hive projects.');
+      console.log('Each project uses a unique database name for isolation.\n');
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
 program
   .command('run [dirPath]')
   .description('Run Hive server')
   .action(async (dirPath = '.') => {
     try {
-      process.env.HIVE_SRC = path.resolve(process.cwd(), dirPath);
+      const hiveSrc = path.resolve(process.cwd(), dirPath);
+      const projectDir = path.resolve(hiveSrc, '..');
+      const hiveProjectDir = path.resolve(projectDir, '.hive');
+
+      // Ensure env config exists
+      await ensureEnvConfig(projectDir);
+
+      // Find available port
+      const defaultPort = parseInt(process.env.PORT) || 3001;
+      const port = await findAvailablePort(defaultPort);
+      if (port !== defaultPort) {
+        console.log(`  Port ${defaultPort} in use, using ${port} instead\n`);
+      }
 
-      const hiveProjectDir = path.resolve(process.env.HIVE_SRC, `../.hive`);
       await execCommand(`mkdir -p ${hiveProjectDir}`);
       await execCommand(`cp -r ${path.resolve(__dirname, '..')}/starter/ ${hiveProjectDir}`);
 
-      tsx.require(`${hiveProjectDir}/src/app.js`, __filename); // TSX doesn't work inside node_moduels
+      const child = spawn('npx', ['tsx', '--watch', 'src/app.js'], {
+        cwd: hiveProjectDir,
+        stdio: 'inherit',
+        env: { ...process.env, HIVE_SRC: hiveSrc, PORT: String(port) }
+      });
+
+      child.on('error', (err) => console.error('Failed to start:', err.message));
+      child.on('close', (code) => process.exit(code));
     } catch (error) {
       console.error('An error occurred:', error.message);
     }
@@ -99,7 +167,11 @@ program
   .action(async (dirPath = '.') => {
     try {
       process.env.HIVE_SRC = path.resolve(process.cwd(), dirPath);
-      const hiveProjectDir = path.resolve(process.env.HIVE_SRC, `../.hive`);
+      const projectDir = path.resolve(process.env.HIVE_SRC, '..');
+      const hiveProjectDir = path.resolve(projectDir, '.hive');
+
+      // Ensure env config exists
+      await ensureEnvConfig(projectDir);
 
       await execCommand(`mkdir -p ${hiveProjectDir}`);
       await execCommand(`cp -r ${path.resolve(__dirname, '..')}/starter/. ${hiveProjectDir}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paralect/hive",
-  "version": "0.1.49",
+  "version": "0.1.50-alpha.0",
   "description": "",
   "main": "index.js",
   "bin": {

package/test-app/.cursor/commands/add-endpoint.md

@@ -0,0 +1,262 @@
+# Add Endpoint
+
+Creates a new API endpoint with inferred types.
+
+## Command Format
+
+```
+add-endpoint {resource} [{name}] {method} [{url}] {fields}
+```
+
+**Examples:**
+- `add-endpoint tasks post title, description, dueOn`
+- `add-endpoint tasks get page, perPage, status`
+- `add-endpoint tasks update /:id title, status`
+- `add-endpoint companies addMember put /:companyId/members user: { _id }, role`
+
+## Method Aliases
+
+| Alias | HTTP Method | Default Name | Default URL |
+|-------|-------------|--------------|-------------|
+| `get` | GET | list | / |
+| `post`, `create` | POST | create | / |
+| `put`, `update` | PUT | update | /:id |
+| `delete` | DELETE | delete | /:id |
+
+## Type Inference Rules
+
+Infer Zod types from field names:
+
+| Pattern | Zod Type |
+|---------|----------|
+| `is*`, `has*`, `can*` (e.g. `isEmpty`, `hasAccess`) | `z.coerce.boolean().nullable().optional()` |
+| `*On`, `*At` (e.g. `dueOn`, `createdAt`) | `z.coerce.date().nullable().optional()` |
+| `page`, `perPage`, `limit`, `offset`, `count`, `*Count` | `z.coerce.number().default(...)` |
+| `entity: { _id }`, `entity: { _id, name }` | `z.object({ ... }).nullable().optional()` |
+| Everything else | `z.coerce.string().nullable().optional()` |
+
+## Important Rules
+
+1. **Services are always plural:** `db.services.companies`, `db.services.tasks`
+2. **URL params from ctx.params:** `:id`, `:companyId` come from `ctx.params`, NOT in requestSchema
+3. **Entity references as objects:** Use `user: { _id }` not `userId`. Full object with `_id` field required.
+4. **Use shouldExist middleware:** To load entities by ID, use `shouldExist` middleware, not `findOne`
+5. **Write fields explicitly:** Don't use spread `...updates`, list each field
+
+## Location
+
+`src/resources/{resource}/endpoints/{name}.js`
+
+## Full Examples
+
+### `add-endpoint tasks post title, description, project: { _id }, dueOn`
+
+Creates `src/resources/tasks/endpoints/create.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const tasksService = db.services.tasks;
+
+export const middlewares = [];
+
+export const requestSchema = z.object({
+  title: z.coerce.string().nullable().optional(),
+  description: z.coerce.string().nullable().optional(),
+  project: z.object({
+    _id: z.string(),
+  }).nullable().optional(),
+  dueOn: z.coerce.date().nullable().optional(),
+});
+
+export const handler = async (ctx) => {
+  const { title, description, project, dueOn } = ctx.validatedData;
+
+  return tasksService.create({
+    user: ctx.state.user,
+    title,
+    description,
+    project,
+    dueOn,
+  });
+};
+
+export const endpoint = {
+  url: '/',
+  method: 'post',
+};
+```
+
+### `add-endpoint tasks get page, perPage, status, isCompleted`
+
+Creates `src/resources/tasks/endpoints/list.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const tasksService = db.services.tasks;
+
+export const middlewares = [];
+
+export const requestSchema = z.object({
+  page: z.coerce.number().default(1),
+  perPage: z.coerce.number().default(20),
+  status: z.coerce.string().nullable().optional(),
+  isCompleted: z.coerce.boolean().nullable().optional(),
+});
+
+export const handler = async (ctx) => {
+  const { page, perPage, status, isCompleted } = ctx.validatedData;
+
+  return tasksService.find(
+    { status, isCompleted },
+    { page, perPage, sort: '-createdOn' }
+  );
+};
+
+export const endpoint = {
+  url: '/',
+  method: 'get',
+};
+```
+
+### `add-endpoint tasks update /:id title, status, assignee: { _id, fullName }`
+
+Creates `src/resources/tasks/endpoints/update.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const tasksService = db.services.tasks;
+
+export const middlewares = [];
+
+export const requestSchema = z.object({
+  title: z.coerce.string().nullable().optional(),
+  status: z.coerce.string().nullable().optional(),
+  assignee: z.object({
+    _id: z.string(),
+  }).nullable().optional(),
+});
+
+export const handler = async (ctx) => {
+  const { title, status, assignee } = ctx.validatedData;
+  const { id } = ctx.params;
+
+  return tasksService.updateOne(
+    { _id: id },
+    (doc) => ({
+      ...doc,
+      title,
+      status,
+      assignee,
+    })
+  );
+};
+
+export const endpoint = {
+  url: '/:id',
+  method: 'put',
+};
+```
+
+### `add-endpoint companies addMember put /:companyId/members user: { _id }, role`
+
+Creates `src/resources/companies/endpoints/addMember.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+import shouldExist from 'middlewares/shouldExist';
+
+const companiesService = db.services.companies;
+
+export const middlewares = [
+  shouldExist('users', (ctx) => ctx.validatedData.user._id),
+];
+
+export const requestSchema = z.object({
+  user: z.object({
+    _id: z.string(),
+  }),
+  role: z.coerce.string().nullable().optional(),
+});
+
+export const handler = async (ctx) => {
+  const { user, role } = ctx.validatedData;
+  const { companyId } = ctx.params;
+
+  return companiesService.updateOne(
+    { _id: companyId },
+    (doc) => ({
+      ...doc,
+      members: [...(doc.members || []), { _id: user._id, role }],
+    })
+  );
+};
+
+export const endpoint = {
+  url: '/:companyId/members',
+  method: 'put',
+};
+```
+
+### `add-endpoint auth login post email, password` (public)
+
+Creates `src/resources/auth/endpoints/login.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const usersService = db.services.users;
+
+export const middlewares = ['allowNoAuth'];
+
+export const requestSchema = z.object({
+  email: z.coerce.string(),
+  password: z.coerce.string(),
+});
+
+export const handler = async (ctx) => {
+  const { email, password } = ctx.validatedData;
+
+  // Auth logic here
+};
+
+export const endpoint = {
+  url: '/login',
+  method: 'post',
+};
+```
+
+### `add-endpoint tasks delete /:id`
+
+Creates `src/resources/tasks/endpoints/delete.js`:
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const tasksService = db.services.tasks;
+
+export const middlewares = [];
+
+export const requestSchema = z.object({});
+
+export const handler = async (ctx) => {
+  const { id } = ctx.params;
+
+  await tasksService.remove({ _id: id });
+
+  return { success: true };
+};
+
+export const endpoint = {
+  url: '/:id',
+  method: 'delete',
+};
+```

package/test-app/.cursor/commands/add-handler.md

@@ -0,0 +1,137 @@
+# Add Handler
+
+Creates a new event handler that reacts to database changes.
+
+## Command Format
+
+```
+add-handler {resource}
+```
+
+**Examples:**
+- `add-handler tasks`
+- `add-handler invoices`
+- `add-handler messages`
+
+## Location
+
+`src/resources/{resource}/handlers/{handlerName}.js`
+
+## Events
+
+| Event | Payload | Trigger |
+|-------|---------|---------|
+| `created` | `{ doc }` | After `service.create()` |
+| `updated` | `{ doc, prevDoc }` | After `service.updateOne/Many()` |
+| `removed` | `{ doc }` | After `service.remove()` |
+
+## Template
+
+```javascript
+import db from 'db';
+import ifUpdated from 'helpers/db/ifUpdated';
+// import ioEmitter from 'ioEmitter';
+
+const {resource}Service = db.services.{resource};
+
+{resource}Service.on('created', async ({ doc }) => {
+});
+
+{resource}Service.on('updated', ifUpdated(['field'], async ({ doc, prevDoc }) => {
+}));
+
+{resource}Service.on('removed', async ({ doc }) => {
+});
+
+/*
+{resource}Service.on('created', async ({ doc }) => {
+  ioEmitter.to(`room-${doc._id}`).emit('{resource}:created', { doc });
+});
+*/
+```
+
+## Examples
+
+### React to specific field changes
+
+```javascript
+import db from 'db';
+import ifUpdated from 'helpers/db/ifUpdated';
+
+const tasksService = db.services.tasks;
+
+tasksService.on('updated', ifUpdated(['status'], async ({ doc, prevDoc }) => {
+  // Only runs when status changed
+}));
+```
+
+### Emit socket event
+
+```javascript
+import db from 'db';
+import ioEmitter from 'ioEmitter';
+
+const messagesService = db.services.messages;
+
+messagesService.on('created', async ({ doc: message }) => {
+  ioEmitter.to(`project-${message.project._id}`).emit('message:created', {
+    message,
+  });
+});
+```
+
+### Add related record
+
+```javascript
+import db from 'db';
+
+const tasksService = db.services.tasks;
+const notificationsService = db.services.notifications;
+
+tasksService.on('created', async ({ doc }) => {
+  if (!doc.assignee?._id) return;
+
+  await notificationsService.create({
+    user: doc.assignee,
+    type: 'task.assigned',
+    data: { task: doc },
+  });
+});
+```
+
+### Cleanup on delete
+
+```javascript
+import db from 'db';
+
+const invoicesService = db.services.invoices;
+const paymentsService = db.services.payments;
+
+invoicesService.on('removed', async ({ doc }) => {
+  await paymentsService.remove({ 'invoice._id': doc._id });
+});
+```
+
+### Bulk update (silent, no events)
+
+```javascript
+import db from 'db';
+import ifUpdated from 'helpers/db/ifUpdated';
+
+const usersService = db.services.users;
+const tasksService = db.services.tasks;
+
+usersService.on('updated', ifUpdated(['fullName', 'avatarUrl'], async ({ doc }) => {
+  await tasksService.atomic.update(
+    { 'assignee._id': doc._id },
+    { $set: { 'assignee.fullName': doc.fullName, 'assignee.avatarUrl': doc.avatarUrl } },
+    { multi: true }
+  );
+}));
+```
+
+## Tips
+
+- Use `ifUpdated` helper to react only when specific fields change
+- Use `atomic.update` for bulk updates (no events triggered)
+- Keep handlers fast — don't block the response

package/test-app/.cursor/commands/add-middleware.md

@@ -0,0 +1,95 @@
+# Add Middleware
+
+Creates a new middleware for endpoints.
+
+## Command Format
+
+```
+add-middleware {name}
+```
+
+**Examples:**
+- `add-middleware isAdmin`
+- `add-middleware canEditProject`
+- `add-middleware rateLimit`
+
+## Location
+
+`src/middlewares/{name}.js`
+
+## Template (simple)
+
+```javascript
+export default async (ctx, next) => {
+  // Middleware logic here
+  
+  return next();
+};
+```
+
+## Template (with parameters)
+
+```javascript
+export default (param) => async (ctx, next) => {
+  // Use param here
+  
+  return next();
+};
+```
+
+## Examples
+
+### Access control
+
+```javascript
+export default async (ctx, next) => {
+  if (!ctx.state.user?.isAdmin) {
+    ctx.throw(403, 'Admin access required');
+  }
+  
+  return next();
+};
+```
+
+### With parameters
+
+```javascript
+import db from 'db';
+
+export default (resource, getId = (ctx) => ctx.params.id) => async (ctx, next) => {
+  const id = getId(ctx);
+  const doc = await db.services[resource].findOne({ _id: id });
+  
+  if (!doc) {
+    ctx.throw(404, `${resource} not found`);
+  }
+  
+  ctx.state[resource] = doc;
+  return next();
+};
+```
+
+### With runOrder (lower runs first)
+
+```javascript
+const middleware = async (ctx, next) => {
+  ctx.state.isSkipAuth = true;
+  return next();
+};
+
+middleware.runOrder = -1;
+
+export default middleware;
+```
+
+## Usage in endpoints
+
+```javascript
+// Import and use directly
+import isAdmin from 'middlewares/isAdmin';
+export const middlewares = [isAdmin];
+
+// With parameters
+import canEdit from 'middlewares/canEdit';
+export const middlewares = [canEdit('projects', (ctx) => ctx.params.projectId)];
+```

package/test-app/.cursor/commands/add-resource.md

@@ -0,0 +1,71 @@
+# Add Resource
+
+Creates a complete resource with schema and folder structure.
+
+## Steps
+
+1. Create folder: `src/resources/{name}/`
+2. Create schema file: `src/resources/{name}/{name}.schema.js`
+3. Create folders: `endpoints/`, `handlers/`, `methods/`
+4. Create first endpoint: `src/resources/{name}/endpoints/list.js`
+
+## Schema Template
+
+**File:** `src/resources/{name}/{name}.schema.js`
+
+```javascript
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema.js';
+
+const schema = dbSchema.extend({
+  // Add fields here
+  title: z.coerce.string().nullable().optional(),
+});
+
+export default schema;
+
+export const secureFields = [];
+```
+
+## First Endpoint Template
+
+**File:** `src/resources/{name}/endpoints/list.js`
+
+```javascript
+import { z } from 'zod';
+import db from 'db';
+
+const {name}Service = db.services.{name};
+
+export const middlewares = [];
+
+export const requestSchema = z.object({
+  page: z.coerce.number().default(1),
+  perPage: z.coerce.number().default(20),
+});
+
+export const handler = async (ctx) => {
+  const { page, perPage } = ctx.validatedData;
+
+  return {name}Service.find(
+    {},
+    { page, perPage, sort: '-createdOn' }
+  );
+};
+
+export const endpoint = {
+  url: '/',
+  method: 'get',
+};
+```
+
+## Result
+
+```
+src/resources/{name}/
+├── {name}.schema.js
+├── endpoints/
+│   └── list.js
+├── handlers/
+└── methods/
+```