@paralect/hive 0.1.49 → 0.1.50-alpha.2

package/.hive/.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["@babel/preset-env", "@babel/preset-react"]
+}

package/.hive/.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/.hive/.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/.hive/.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/.hive/.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/
+```

package/.hive/.cursor/commands/add-scheduler.md

@@ -0,0 +1,138 @@
+# Add Scheduler
+
+Creates a new scheduled background job.
+
+## Command Format
+
+```
+add-scheduler {name} [{schedule}]
+```
+
+**Examples:**
+- `add-scheduler syncExternalData every 5 minutes`
+- `add-scheduler sendDailyReport daily at 9am`
+- `add-scheduler markOverdueInvoices every day at midnight`
+- `add-scheduler weeklyCleanup every monday at 3am`
+
+## Schedule to Cron
+
+Translate natural language to cron:
+
+| User says | Cron |
+|-----------|------|
+| every minute | `* * * * *` |
+| every 5 minutes | `*/5 * * * *` |
+| every hour | `0 * * * *` |
+| every 6 hours | `0 */6 * * *` |
+| daily at midnight | `0 0 * * *` |
+| daily at 9am | `0 9 * * *` |
+| every monday at 9am | `0 9 * * 1` |
+| first of month | `0 0 1 * *` |
+
+## Location
+
+`src/scheduler/handlers/{name}.js`
+
+## Template
+
+```javascript
+import db from 'db';
+
+export const handler = async () => {
+  // Job logic here
+};
+
+export const cron = '0 * * * *'; // Every hour
+```
+
+## Examples
+
+### Sync external data
+
+```javascript
+import db from 'db';
+import moment from 'moment';
+import externalApi from 'services/externalApi';
+
+const itemsService = db.services.items;
+
+export const handler = async () => {
+  const items = await externalApi.list({
+    updatedSince: moment().subtract(5, 'minutes').toDate(),
+  });
+
+  for (const item of items) {
+    await itemsService.updateOne(
+      { externalId: item.id },
+      (doc) => ({ ...doc, ...item })
+    );
+  }
+};
+
+export const cron = '*/5 * * * *';
+```
+
+### Send daily report
+
+```javascript
+import db from 'db';
+import slack from 'services/slack';
+
+const tasksService = db.services.tasks;
+
+export const handler = async () => {
+  const { count: completed } = await tasksService.find({ status: 'completed' });
+  const { count: pending } = await tasksService.find({ status: 'pending' });
+
+  await slack.sendChannelMessage({
+    channel: '#reports',
+    text: `Daily report: ${completed} completed, ${pending} pending`,
+  });
+};
+
+export const cron = '0 9 * * *';
+```
+
+### Mark overdue invoices
+
+```javascript
+import db from 'db';
+
+const invoicesService = db.services.invoices;
+
+export const handler = async () => {
+  await invoicesService.updateMany(
+    {
+      isPaid: { $ne: true },
+      isOverdue: { $ne: true },
+      dueOn: { $lt: new Date() },
+    },
+    (doc) => ({ ...doc, isOverdue: true })
+  );
+};
+
+export const cron = '0 0 * * *';
+```
+
+### Cleanup old records
+
+```javascript
+import db from 'db';
+import moment from 'moment';
+
+const logsService = db.services.logs;
+
+export const handler = async () => {
+  await logsService.remove({
+    createdOn: { $lt: moment().subtract(30, 'days').toDate() },
+  });
+};
+
+export const cron = '0 3 * * *';
+```
+
+## Tips
+
+- Keep jobs idempotent (safe to re-run)
+- Log progress for debugging
+- Use `atomic.update` for bulk operations