@paralect/hive 0.1.49 → 0.1.50-alpha.0

package/.hive/.cursor/skills/hive-middleware/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: hive-middleware
+description: How to create and use middlewares in Hive framework
+globs:
+  - src/middlewares/*.js
+alwaysApply: false
+---
+
+# Middlewares
+
+Location: `/src/middlewares/{name}.js`
+
+## Built-in Middlewares
+
+| Name | Purpose |
+|------|---------|
+| `allowNoAuth` | Skip authentication |
+| `isAuthorized` | Require authenticated user |
+| `shouldExist` | Load resource, 404 if not found |
+| `attachUser` | Load user from token |
+
+## Creating Middleware
+
+**Simple:**
+```javascript
+export default async (ctx, next) => {
+  // Before handler
+  if (!ctx.state.user?.isAdmin) {
+    ctx.throw(403, 'Admin only');
+  }
+  return next();  // Don't forget!
+};
+```
+
+**With parameters:**
+```javascript
+export default (resourceName) => async (ctx, next) => {
+  const doc = await db.services[resourceName].findOne({
+    _id: ctx.params[`${resourceName}Id`],
+  });
+  
+  if (!doc) ctx.throw(404, `${resourceName} not found`);
+  
+  ctx.state[resourceName] = 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;
+```
+
+## Using in Endpoints
+
+```javascript
+// By name
+export const middlewares = ['allowNoAuth'];
+
+// With arguments
+export const middlewares = [{ name: 'shouldExist', args: ['projects'] }];
+
+// Direct import
+import isAdmin from 'middlewares/isAdmin';
+export const middlewares = [isAdmin];
+
+// Factory function
+import canEditProject from 'middlewares/canEditProject';
+export const middlewares = [canEditProject((ctx) => ctx.params.projectId)];
+
+// Inline
+export const middlewares = [
+  async (ctx, next) => {
+    // Custom logic
+    return next();
+  },
+];
+```
+
+## Global Middleware
+
+Create `/src/middlewares/global.js` to run on all endpoints:
+
+```javascript
+import isAuthorized from 'middlewares/isAuthorized';
+import attachRootProject from 'middlewares/attachRootProject';
+
+export default async (ctx, next) => {
+  await isAuthorized(ctx, async () => {
+    await attachRootProject(ctx, next);
+  });
+};
+```
+
+## Rules
+
+- Always call `next()` or throw
+- Use `runOrder` to control execution order
+- Factory functions for parameterized middlewares

package/.hive/.cursor/skills/hive-overview/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: hive-overview
+description: Hive framework structure and conventions. Apply when working with this codebase.
+globs:
+  - src/**/*.js
+alwaysApply: false
+---
+
+# Hive Framework Overview
+
+Hive is a Koa-based Node.js framework with MongoDB, Zod validation, and auto-sync for embedded documents.
+
+## Directory Structure
+
+| Directory | Purpose | Edit? |
+|-----------|---------|-------|
+| `/.hive/` | Framework core | No - read only |
+| `/src/` | Application code | Yes |
+
+## Resources
+
+A resource is a feature module in `/src/resources/{name}/`:
+
+```
+src/resources/{name}/
+├── {name}.schema.js      # Required: DB schema
+├── endpoints/            # API routes
+├── handlers/             # Event listeners
+└── methods/              # Reusable functions
+```
+
+## Built-in (in .hive/)
+
+- `tokens` - Auth token storage
+- `users` - Base user schema  
+- `db` - Database layer with services
+
+## Key Imports
+
+```javascript
+import db from 'db';                    // Database
+import config from 'app-config';        // Config
+import { z } from 'zod';                // Validation
+```
+
+## Services Access
+
+```javascript
+const taskService = db.services.tasks;  // Auto-created from schema
+```

package/.hive/.cursor/skills/hive-scheduler/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: hive-scheduler
+description: How to create scheduled jobs in Hive framework
+globs:
+  - src/scheduler/handlers/*.js
+alwaysApply: false
+---
+
+# Scheduler Jobs
+
+Background jobs on cron schedules.
+
+Location: `/src/scheduler/handlers/{jobName}.js`
+
+## Template
+
+```javascript
+import db from 'db';
+
+export const handler = async () => {
+  // Job logic
+};
+
+export const cron = '0 * * * *';  // Every hour
+```
+
+## Cron Patterns
+
+```
+┌─ minute (0-59)
+│ ┌─ hour (0-23)
+│ │ ┌─ day of month (1-31)
+│ │ │ ┌─ month (1-12)
+│ │ │ │ ┌─ day of week (0-6)
+* * * * *
+```
+
+| Pattern | Schedule |
+|---------|----------|
+| `* * * * *` | Every minute |
+| `*/5 * * * *` | Every 5 minutes |
+| `0 * * * *` | Every hour |
+| `0 */12 * * *` | Every 12 hours |
+| `0 0 * * *` | Daily at midnight |
+| `0 9 * * 1` | Mondays at 9am |
+
+## Examples
+
+**Sync external data:**
+```javascript
+import db from 'db';
+import moment from 'moment';
+import externalApi from 'services/externalApi';
+
+export const handler = async () => {
+  const items = await externalApi.list({
+    updatedSince: moment().subtract(5, 'minutes').toDate(),
+  });
+  
+  for (const item of items) {
+    await db.services.items.updateOne(
+      { externalId: item.id },
+      (doc) => ({ ...doc, ...item })
+    );
+  }
+};
+
+export const cron = '*/5 * * * *';
+```
+
+**Mark overdue:**
+```javascript
+import db from 'db';
+import moment from 'moment';
+
+export const handler = async () => {
+  await db.services.invoices.updateMany(
+    {
+      isPaid: { $ne: true },
+      isDue: { $ne: true },
+      dueOn: { $lt: new Date() },
+    },
+    (doc) => ({ ...doc, isDue: true })
+  );
+};
+
+export const cron = '0 */12 * * *';
+```
+
+## Rules
+
+- Export both `handler` and `cron`
+- Keep jobs idempotent (safe to re-run)
+- Log progress for debugging

package/.hive/.cursor/skills/hive-schema/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: hive-schema
+description: How to create database schemas in Hive framework
+globs:
+  - src/resources/**/*.schema.js
+alwaysApply: false
+---
+
+# Creating Database Schemas
+
+Location: `/src/resources/{name}/{name}.schema.js`
+
+## Template
+
+```javascript
+import { z } from 'zod';
+import dbSchema from 'helpers/schema/db.schema.js';
+
+const schema = dbSchema.extend({
+  // Fields here
+});
+
+export default schema;
+
+export const secureFields = []; // Hidden from API responses
+```
+
+## Field Patterns
+
+**Simple fields:**
+```javascript
+title: z.coerce.string().nullable().optional(),
+count: z.coerce.number().nullable().optional(),
+isActive: z.coerce.boolean().nullable().optional(),
+dueOn: z.coerce.date().nullable().optional(),
+```
+
+**Reference to another document:**
+```javascript
+user: z
+  .object({
+    _id: z.string(),
+    fullName: z.coerce.string().nullable().optional(),
+    avatarUrl: z.coerce.string().nullable().optional(),
+  })
+  .nullable()
+  .optional(),
+```
+
+**Array of references:**
+```javascript
+managers: z
+  .array(
+    z.object({
+      _id: z.string(),
+      fullName: z.coerce.string().nullable().optional(),
+    }).nullable().optional(),
+  )
+  .nullable()
+  .optional(),
+```
+
+**Flexible object:**
+```javascript
+data: z.object({}).passthrough().nullable().optional(),
+```
+
+## Rules
+
+- Always use `z.coerce` for type safety
+- Always add `.nullable().optional()` unless required
+- Include fields you need in references (for auto-sync)
+- Add sensitive fields to `secureFields` array

package/.hive/.cursor/skills/hive-service/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: hive-service
+description: How to create external services in Hive framework
+globs:
+  - src/services/*.js
+alwaysApply: false
+---
+
+# Services
+
+Services wrap external APIs and utilities.
+
+Location: `/src/services/{name}.js`
+
+## API Client Template
+
+```javascript
+import config from 'app-config';
+import axios from 'axios';
+
+const client = axios.create({
+  baseURL: 'https://api.example.com',
+  headers: {
+    Authorization: `Bearer ${config.example.apiKey}`,
+  },
+});
+
+export default {
+  getItems: async (params) => {
+    const response = await client.get('/items', { params });
+    return response.data;
+  },
+  
+  createItem: async (data) => {
+    const response = await client.post('/items', data);
+    return response.data;
+  },
+};
+```
+
+## SDK Wrapper Template
+
+```javascript
+import config from 'app-config';
+import { WebClient } from '@slack/web-api';
+
+const client = new WebClient(config.slack.botToken);
+
+export default {
+  client,
+  
+  postMessage: async ({ channel, text }) => {
+    return client.chat.postMessage({ channel, text });
+  },
+};
+```
+
+## Utility Service Template
+
+```javascript
+import _ from 'lodash';
+
+export const when = (condition, result, elseResult = {}) => {
+  if (_.isUndefined(condition)) return {};
+  if (!condition) return elseResult;
+  return _.isFunction(result) ? result() : result;
+};
+
+export const base64 = {
+  encode: (obj) => Buffer.from(JSON.stringify(obj)).toString('base64'),
+  decode: (str) => JSON.parse(Buffer.from(str, 'base64').toString()),
+};
+```
+
+## Using Services
+
+```javascript
+import harvest from 'services/harvest';
+import slackService from 'services/slack';
+import { when } from 'services/utils';
+
+// API calls
+const invoices = await harvest.getInvoices({ projectId });
+
+// SDK usage
+await slackService.postMessage({ channel: '#general', text: 'Hello' });
+
+// Utilities
+const query = { ...when(status, { status }) };
+```

package/.hive/.dockerignore

@@ -0,0 +1 @@
+node_modules

package/.hive/Dockerfile

@@ -0,0 +1,22 @@
+FROM --platform=linux/amd64 node:16.13.1-alpine3.13 as base
+RUN apk add --no-cache python3 py3-pip
+
+ENV NODE_ENV=production
+ENV APP_ENV=production
+
+WORKDIR /app
+EXPOSE 3001
+COPY ["./package*.json", "/app/"]
+
+RUN npm set progress=false && npm config set depth 0
+
+RUN npm set-script prepare ""
+
+RUN npm ci --only=production --quiet
+
+COPY ./ ./
+
+RUN mkdir -p /project/logs
+RUN touch /project/logs/log.txt
+
+CMD npm start 2>&1 | tee /project/logs/log.txt

package/.hive/Dockerfile.dev

@@ -0,0 +1,33 @@
+FROM node:16.13.1-alpine3.13 as base
+RUN apk add --no-cache python3 py3-pip
+
+ARG NODE_ENV=development
+ARG APP_ENV
+ARG PROJECT_SRC=/project
+
+ENV NODE_ENV=$NODE_ENV
+ENV APP_ENV=$APP_ENV
+ENV PROJECT_SRC=$PROJECT_SRC
+
+WORKDIR /app
+COPY ["./package*.json", "/app/"]
+# Disable husky
+RUN npm set-script prepare ""
+
+RUN npm ci --quiet
+COPY . ./
+
+RUN npm run build-assets
+
+FROM base as migrator
+CMD npm run migrate
+
+FROM base as scheduler
+CMD npm run schedule-dev
+
+FROM base as api
+
+EXPOSE 3001
+EXPOSE 3012
+
+CMD npm run dev 2>&1 | tee /logs/log.txt

package/.hive/Dockerfile.prod

@@ -0,0 +1,29 @@
+FROM node:16.13.1-alpine3.13 as base
+RUN apk add --no-cache python3 py3-pip
+
+ENV NODE_ENV=production
+ENV APP_ENV=production
+
+WORKDIR /app
+EXPOSE 3001
+COPY ["./package*.json", "./.eslintrc.js", "/app/"]
+
+RUN npm set progress=false && npm config set depth 0
+
+RUN npm set-script prepare ""
+
+RUN npm ci --only=production --quiet
+
+COPY ./ ./
+
+RUN ls /app/src/config/.env
+
+RUN rm /app/src/config/.env
+RUN mv /app/src/config/.env.production /app/src/config/.env
+
+RUN cat /app/src/config/.env
+
+RUN mkdir -p /project/logs
+RUN touch /project/logs/log.txt
+
+CMD npm start 2>&1 | tee /project/logs/log.txt

package/.hive/README.md

@@ -0,0 +1,11 @@
+# API 🧩
+
+## Start
+
+To start a server in the docker container use bash `./bin/start.sh`:
+
+```bash
+$ ./bin/start.sh
+```
+
+It'll start a docker-compose in dev mode (API + Mongo)

package/.hive/bin/deploy.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+cd "$( dirname "${BASH_SOURCE[0]}" )"
+cd ..
+
+node ./deploy/script/src/index.js

package/.hive/bin/start.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+docker-compose up --build

package/.hive/bootstrap-hive.js

@@ -0,0 +1,118 @@
+const fs = require("fs");
+const path = require("path");
+
+// Function to create directories recursively
+function mkdirRecursive(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Function to convert JSON schema to JavaScript code
+function convertJsonToJs(schema) {
+  let jsCode = "const Joi = require('joi');\n\n";
+  jsCode += `const ${schema.name} = Joi.object({\n`;
+  for (const [key, value] of Object.entries(schema.schema)) {
+    if (typeof value === "object" && !Array.isArray(value)) {
+      jsCode += `  ${key}: Joi.object({\n`;
+      for (const [subKey, subValue] of Object.entries(value)) {
+        jsCode += `    ${subKey}: ${subValue},\n`;
+      }
+      jsCode += `  }),\n`;
+    } else {
+      jsCode += `  ${key}: ${value},\n`;
+    }
+  }
+  jsCode += "});\n\n";
+  jsCode += `module.exports = ${schema.name};\n`;
+  return jsCode;
+}
+
+// Function to generate endpoint code
+function createEndpointCode(endpoint) {
+  let requestSchema = "const Joi = require('joi');\n\n";
+  requestSchema += "module.exports.requestSchema = Joi.object({\n";
+  for (const [key, value] of Object.entries(endpoint.requestSchema)) {
+    requestSchema += `  ${key}: ${value},\n`;
+  }
+  requestSchema += "});\n\n";
+
+  return `
+  ${endpoint.handler}
+
+${requestSchema}
+module.exports.endpoint = ${JSON.stringify(endpoint.endpoint, null, 2)};
+`;
+}
+
+// Main function to generate the project structure
+function generateProjectStructure(resources) {
+  resources.forEach((resource) => {
+    const resourceDir = path.join(__dirname, "src", "resources", resource.name);
+    mkdirRecursive(resourceDir);
+
+    // Create schemas directory and files
+    if (resource.schemas) {
+      const schemaDir = path.join(resourceDir);
+      mkdirRecursive(schemaDir);
+      resource.schemas.forEach((schema) => {
+        const schemaCode = convertJsonToJs(schema);
+        fs.writeFileSync(
+          path.join(schemaDir, `${schema.name.toLowerCase()}.schema.js`),
+          schemaCode
+        );
+      });
+    }
+
+    // Create endpoints directory and files
+    if (resource.endpoints) {
+      const endpointDir = path.join(resourceDir, "endpoints");
+      mkdirRecursive(endpointDir);
+      resource.endpoints.forEach((endpoint) => {
+        const endpointCode = createEndpointCode(endpoint);
+        fs.writeFileSync(
+          path.join(endpointDir, `${endpoint.name}.js`),
+          endpointCode
+        );
+      });
+    }
+
+    // Create handlers directory and files
+    if (resource.handlers) {
+      const handlerDir = path.join(resourceDir, "handlers");
+      mkdirRecursive(handlerDir);
+      resource.handlers.forEach((handler) => {
+        const handlerCode = handler.handler;
+        fs.writeFileSync(
+          path.join(handlerDir, `${handler.name}.js`),
+          handlerCode
+        );
+      });
+    }
+
+    // Create methods directory and files
+    if (resource.methods) {
+      const methodDir = path.join(resourceDir, "methods");
+      mkdirRecursive(methodDir);
+      resource.methods.forEach((method) => {
+        const methodCode = method.handler;
+        fs.writeFileSync(path.join(methodDir, `${method.name}.js`), methodCode);
+      });
+    }
+  });
+}
+
+// Main entry point
+const [, , jsonFilePath] = process.argv;
+
+if (!jsonFilePath) {
+  console.error("Please provide the path to the JSON file.");
+  process.exit(1);
+}
+
+const rawData = fs.readFileSync(jsonFilePath, "utf8");
+const { resources } = JSON.parse(rawData);
+
+generateProjectStructure(resources);
+
+console.log("Hive-based project structure generated successfully.");

package/.hive/deploy/api/Chart.yaml

@@ -0,0 +1,6 @@
+apiVersion: v2
+name: hive-api
+description: A Helm chart for Kubernetes
+type: application
+version: 0.1.0
+appVersion: 1.16.0

package/.hive/deploy/api/staging.yaml

@@ -0,0 +1,3 @@
+nodePool: pool-app
+containerRegistry: paralect/hive-api
+port: 3001

package/.hive/deploy/api/templates/deployment.yaml

@@ -0,0 +1,44 @@
+kind: Deployment
+apiVersion: apps/v1
+metadata:
+  name: {{ .Values.service }}
+  labels:
+    app: {{ .Values.service }}
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: {{ .Values.service }}
+  template:
+    metadata:
+      labels:
+        app: {{ .Values.service }}
+    spec:
+      restartPolicy: Always
+      containers:
+        - name: {{ .Values.service }}
+          image: {{ .Values.containerRegistry }}:{{ .Values.imagesVersion }}
+          env:
+            - name: PROJECT_ID
+              value: {{ .Values.projectId }}
+            {{- range .Values.env }}
+            - name: {{ .name }}
+              value: {{ .value }}
+            {{- end }}
+          imagePullPolicy: Always
+          livenessProbe:
+            httpGet:
+              path: /health
+              port: {{ .Values.port }}
+            initialDelaySeconds: 300
+            periodSeconds: 10
+          ports:
+            - containerPort: {{ .Values.port }}
+              protocol: TCP
+      nodeSelector:
+        doks.digitalocean.com/node-pool: {{ .Values.nodePool }}
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 0
+      maxSurge: 1