@paralect/hive 0.1.50-alpha.2 → 0.1.50

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

@@ -1,137 +0,0 @@
-# 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

@@ -1,95 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-# 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/test-app/.cursor/commands/add-scheduler.md

@@ -1,138 +0,0 @@
-# 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

package/test-app/.cursor/skills/hive-auth/SKILL.md

@@ -1,134 +0,0 @@
----
-name: hive-auth
-description: How authentication works in Hive framework
-globs:
-  - src/resources/auth/**/*.js
-alwaysApply: false
----
-
-# Authentication
-
-Hive provides auth infrastructure but **no built-in auth endpoints**. You implement login/signup yourself.
-
-## Built-in (in .hive/)
-
-- `tokens` collection - stores access tokens
-- `attachUser` middleware - loads user from token
-- `isAuthorized` middleware - requires auth
-- `allowNoAuth` middleware - skips auth
-
-## How It Works
-
-1. Token extracted from cookie `access_token` or `Authorization: Bearer` header
-2. Token looked up in `tokens` collection
-3. User loaded from `users` collection
-4. User attached to `ctx.state.user`
-
-## Token Schema (built-in)
-
-```javascript
-{
-  _id: string,
-  user: { _id: string },
-  token: string,
-  metadata: object (optional),
-}
-```
-
-## Implement Auth Endpoints
-
-**1. Create token helper:**
-```javascript
-// src/resources/auth/methods/createToken.js
-import db from 'db';
-import crypto from 'crypto';
-
-const tokenService = db.services.tokens;
-
-export default async (ctx, { userId, metadata }) => {
-  const token = crypto.randomBytes(32).toString('hex');
-  
-  await tokenService.create({
-    token,
-    user: { _id: userId },
-    ...(metadata && { metadata }),
-  });
-  
-  ctx.cookies.set('access_token', token, {
-    httpOnly: false,
-    expires: new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1000),
-  });
-  
-  return { token };
-};
-```
-
-**2. Login endpoint:**
-```javascript
-// src/resources/auth/endpoints/login.js
-import { z } from 'zod';
-import db from 'db';
-import bcrypt from 'bcrypt';
-import createToken from '../methods/createToken';
-
-export const handler = async (ctx) => {
-  const { email, password } = ctx.validatedData;
-  
-  const user = await db.services.users.findOne(
-    { email },
-    { isIncludeSecureFields: true }
-  );
-  ctx.assert(user, 401, 'Invalid credentials');
-  
-  const valid = await bcrypt.compare(password, user.password);
-  ctx.assert(valid, 401, 'Invalid credentials');
-  
-  const { token } = await createToken(ctx, { userId: user._id });
-  return { user, token };
-};
-
-export const middlewares = ['allowNoAuth'];
-export const endpoint = { url: '/login', method: 'post' };
-export const requestSchema = z.object({
-  email: z.string().email(),
-  password: z.string(),
-});
-```
-
-**3. Logout endpoint:**
-```javascript
-// src/resources/auth/endpoints/logout.js
-import { z } from 'zod';
-import db from 'db';
-
-export const handler = async (ctx) => {
-  await db.services.tokens.remove({ token: ctx.state.accessToken });
-  ctx.cookies.set('access_token', null);
-  return { success: true };
-};
-
-export const endpoint = { url: '/logout', method: 'post' };
-export const requestSchema = z.object({});
-```
-
-## Users Schema (add password)
-
-```javascript
-// src/resources/users/users.schema.js
-password: z.coerce.string().nullable().optional(),
-
-// Hide from responses
-export const secureFields = ['password'];
-```
-
-## Client Usage
-
-**Browser (cookies):**
-```javascript
-await fetch('/auth/login', { method: 'POST', credentials: 'include', body });
-```
-
-**API (header):**
-```javascript
-await fetch('/tasks', { headers: { Authorization: `Bearer ${token}` } });
-```

package/test-app/.cursor/skills/hive-database/SKILL.md

@@ -1,103 +0,0 @@
----
-name: hive-database
-description: Database operations in Hive framework
-globs:
-  - src/**/*.js
-alwaysApply: false
----
-
-# Database Operations
-
-## Access Service
-
-```javascript
-import db from 'db';
-const taskService = db.services.tasks;  // From schema name
-```
-
-## Find Operations
-
-```javascript
-// Find many
-const { results, pagesCount, count } = await service.find(
-  { status: 'active' },
-  { page: 1, perPage: 20, sort: '-createdOn', fields: ['_id', 'title'] }
-);
-
-// Find one
-const doc = await service.findOne({ _id: id });
-
-// Check exists
-const exists = await service.exists({ _id: id });
-
-// Count
-const total = await service.count({ status: 'active' });
-
-// Distinct values
-const statuses = await service.distinct('status');
-
-// Aggregate
-const { results } = await service.aggregate([
-  { $match: { status: 'done' } },
-  { $group: { _id: '$project._id', count: { $sum: 1 } } },
-]);
-```
-
-## Write Operations
-
-```javascript
-// Create
-const doc = await service.create({ title: 'New', user: ctx.state.user });
-
-// Update one (must use function)
-const updated = await service.updateOne(
-  { _id: id },
-  (doc) => ({ ...doc, title: 'Updated' })
-);
-
-// Update many
-await service.updateMany(
-  { status: 'pending' },
-  (doc) => ({ ...doc, status: 'active' })
-);
-
-// Remove
-await service.remove({ _id: id });
-
-// Generate ID
-const newId = service.generateId();
-```
-
-## Atomic Operations (No Events)
-
-```javascript
-// Silent bulk update
-await service.atomic.update(
-  { 'project._id': projectId },
-  { $set: { 'project.name': newName } },
-  { multi: true }
-);
-```
-
-## Query Patterns
-
-```javascript
-import { when } from 'services/utils';
-
-const { results } = await service.find({
-  // Conditional fields
-  ...when(status, { status }),
-  ...when(userId, { 'user._id': userId }),
-  
-  // Complex conditions
-  status: { $in: ['active', 'pending'] },
-  createdOn: { $gte: startDate, $lt: endDate },
-  $or: [{ 'user._id': id }, { isPublic: true }],
-});
-```
-
-## Rules
-
-- `updateOne` requires a function, not an object
-- Use `atomic.update` for bulk/silent updates
-- Use `when()` helper for conditional query building