@paralect/hive 0.1.48 → 0.1.50-alpha.0

package/cli/hive.js

@@ -7,33 +7,171 @@ 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]')
+  .description('Initialize a new Hive project')
+  .action(async (projectName) => {
+    try {
+      let name = projectName;
+
+      if (!name) {
+        const answer = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: 'my-hive-app'
+          }
+        ]);
+        name = answer.projectName;
+      }
+
+      const projectDir = path.resolve(process.cwd(), name);
+
+      console.log(`\n🐝 Creating Hive project: ${name}\n`);
+
+      await execCommand(`mkdir -p ${projectDir}/src/resources`);
+      await execCommand(`mkdir -p ${projectDir}/src/middlewares`);
+      await execCommand(`mkdir -p ${projectDir}/src/services`);
+      await execCommand(`mkdir -p ${projectDir}/src/scheduler/handlers`);
+
+      fs.writeFileSync(
+        path.join(projectDir, 'package.json'),
+        JSON.stringify({
+          name,
+          ...appPackage
+
+        }, null, 2)
+      );
+
+      const redisDb = hashCode(name) % 16;
+      fs.writeFileSync(
+        path.join(projectDir, '.env'),
+        `MONGODB_URI=mongodb://localhost:27017/${name}\nREDIS_URI=redis://localhost:6379/${redisDb}\nPORT=3001\nNODE_ENV=development\n`
+      );
+
+      fs.writeFileSync(
+        path.join(projectDir, '.gitignore'),
+        `node_modules\n.hive\n.env\n`
+      );
+
+      await execCommand(`cp -r ${path.resolve(__dirname, '..')}/starter/.cursor ${projectDir}/`);
+
+      console.log(`✅ Project created!\n`);
+      console.log(`Next steps:\n`);
+      console.log(`  cd ${name}`);
+      console.log(`  hive run ./src\n`);
+      console.log(`Start building with AI commands:`);
+      console.log(`  add-resource tasks`);
+      console.log(`  add-endpoint tasks post title, status\n`);
+    } catch (error) {
+      console.error('An error occurred:', error.message);
+    }
+  });
+
+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 hiveProjectDir = path.resolve(process.env.HIVE_SRC, `../.hive`);
+      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`);
+      }
+
       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);
     }
   });
 
-  program
+program
   .command('prepare [dirPath]')
   .description('Prepare Hive server')
   .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}`);
@@ -42,7 +180,7 @@ program
     }
   });
 
-  program
+program
   .command('deploy')
   .description('Build hive project')
   .action(async () => {
@@ -50,7 +188,7 @@ program
       let outDir = path.resolve(process.cwd(), './dist');
       await mergeDirs({ hiveSrc: path.resolve(process.cwd()), outDir });
 
-      console.log('outDir',  path.resolve(outDir, `./deploy/script`))
+      console.log('outDir', path.resolve(outDir, `./deploy/script`))
       await execCommand(`npm install --prefix ${path.resolve(outDir, `./deploy/script`)}`);
 
       await execCommand('node ./index.js', {
@@ -67,7 +205,7 @@ program
   .action(async (plugin) => {
     try {
       const destDir = process.cwd();
-      
+
       await downloadDirectory(plugin);
     } catch (error) {
       console.error('An error occurred:', error.message);
@@ -80,12 +218,14 @@ program
   .description('Login into Hive Cloud')
   .action(async () => {
     if (process.env.HIVE_TOKEN) {
-      const user = (await axios({ url: `https://hive-api-test.paralect.co/users/me`, method: 'get', headers: {
-        'Authorization': `Bearer ${process.env.HIVE_TOKEN}`
-      } })).data;
+      const user = (await axios({
+        url: `https://hive-api-test.paralect.co/users/me`, method: 'get', headers: {
+          'Authorization': `Bearer ${process.env.HIVE_TOKEN}`
+        }
+      })).data;
 
       console.log(`Already logged in!`, user);
-      
+
       return;
     }
 
@@ -99,7 +239,7 @@ program
 
     try {
       await axios({ url: `https://hive-api-test.paralect.co/auth/login-code`, method: 'post', data: { email } });
-      
+
       const { code } = await inquirer.prompt([
         {
           type: 'input',

package/package.json

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

package/starter/.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/starter/.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