@paralect/hive 0.1.50-alpha.2 → 0.1.50

package/{.hive/src/resources/schemaMappings/schemaMappings.schema.js → framework/src/resources/schemaMappings/schemaMappings.schema.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import dbSchema from 'helpers/schema/db.schema';
+import dbSchema from 'common/schema/db.schema';
 
 export default dbSchema.extend({
   mappings: z.object({}),

package/{.hive/src/routes/index.js → framework/src/routes/index.ts}

@@ -6,11 +6,10 @@ import mount from "koa-mount";
 import Router from "@koa/router";
 import validate from "middlewares/validate";
 import db from "db";
-import tryToAttachUser from "middlewares/global/tryToAttachUser";
+import extractUserTokens from "middlewares/global/extractUserTokens";
 import attachCustomErrors from "./middlewares/attachCustomErrors";
 import routeErrorHandler from "./middlewares/routeErrorHandler";
-import isAuthorized from "middlewares/isAuthorized";
-import config from 'app-config';
+import config from 'config';
 
 const requestLogService = db.createService("_request_logs");
 
@@ -67,19 +66,23 @@ export default async (app) => {
   app.use(logRequestToMongo);
   app.use(attachCustomErrors);
   app.use(routeErrorHandler);
-  app.use(tryToAttachUser);
+  app.use(extractUserTokens);
 
   const [resources, allMiddlewares] = await Promise.all([getResources(), getMiddlewares()]);
 
   await Promise.all(_.map(resources, async ({ name: resourceName }) => {
     const resourceRouter = new Router();
     const globalRouter = new Router();
-    const endpoints = await Promise.all((await getResourceEndpoints(resourceName))
+    const endpoints = (await Promise.all((await getResourceEndpoints(resourceName))
       .map(async ({ file: endpointFile, name }) => {
         let endpointDef = (await import(endpointFile));
 
-        if (!endpointDef.endpoint) {
-          console.log('missing endpoint for', name);
+        if (endpointDef.default?.endpoint && endpointDef.default?.handler) {
+          endpointDef = endpointDef.default;
+        }
+
+        if (!endpointDef.endpoint || !endpointDef.handler) {
+          return null;
         }
         endpointDef.endpoint.name = name;
 
@@ -89,15 +92,13 @@ export default async (app) => {
           middlewares: endpointDef.middlewares,
           handler: endpointDef.handler,
         };
-      })
-      .sort((e) => {
-        e.endpoint = e.endpoint || { method: "get", url: "/" };
-        const url = e.endpoint.url || e.endpoint.absoluteUrl;
-        if (url.includes("/:")) {
-          return 1;
-        }
-        return -1;
-      }));
+      })))
+      .filter(Boolean)
+      .sort((a, b) => {
+        const urlA = a.endpoint.url || a.endpoint.absoluteUrl || '/';
+        const urlB = b.endpoint.url || b.endpoint.absoluteUrl || '/';
+        return urlA.includes('/:') ? 1 : urlB.includes('/:') ? -1 : 0;
+      });
 
     endpoints.forEach(({ endpoint, requestSchema, middlewares = [], handler }) => {
       let targetRouter;
@@ -114,7 +115,7 @@ export default async (app) => {
         targetRouter = resourceRouter;
       }
 
-      const globalMiddleware = allMiddlewares.find(m => m.name === 'global');
+      const globalMiddleware = allMiddlewares.find(m => m.name === 'global') || allMiddlewares.find(m => m.name === '_global');
 
       if (globalMiddleware) {
         globalMiddleware.runOrder = 0;
@@ -141,20 +142,13 @@ export default async (app) => {
         return middleware;
       });
 
-
-      if (config._hive.isRequireAuthAllEndpoints) {
-        isAuthorized.runOrder = 0;
-        middlewares.unshift(isAuthorized);
-      }
-
-      targetRouter[endpoint.method?.toLowerCase() || "get"](
-        url,
+      const routeMiddlewares = [
         async (ctx, next) => {
           ctx.state.resourceName = resourceName;
           ctx.state.endpoint = endpoint;
           await next();
         },
-        validate(requestSchema),
+        ...(requestSchema ? [validate(requestSchema)] : []),
         ..._.sortBy(middlewares, m => m.runOrder),
         async ctx => {
           const result = await handler(ctx);
@@ -163,7 +157,9 @@ export default async (app) => {
             ctx.body = result || { isOk: true };
           }
         }
-      );
+      ];
+
+      targetRouter[endpoint.method?.toLowerCase() || "get"](url, ...routeMiddlewares);
     });
 
     app.use(globalRouter.routes());

package/framework/src/schema.ts

@@ -0,0 +1,3 @@
+export { default as dbSchema } from './common/schema/db.schema';
+export { paginationSchema } from './common/schema/pagination.schema';
+export { z } from 'zod';

package/{.hive/src/services/emailService.js → framework/src/services/emailService.ts}

@@ -1,4 +1,4 @@
-import config from 'app-config';
+import config from 'config';
 import nodemailer from 'nodemailer';
 
 config.assert('smtp');

package/{.hive/src/socketIo.js → framework/src/socketIo.ts}

@@ -2,7 +2,7 @@ import db from 'db';
 import { Server } from 'socket.io';
 import { createClient } from 'redis';
 import { createAdapter } from '@socket.io/redis-adapter';
-import config from 'app-config';
+import config from 'config';
 import logger from 'logger';
 
 export default (server) => {

package/{.hive → framework}/tsconfig.json

@@ -1,31 +1,35 @@
 {
 	"compilerOptions": {
-
 		// Treat files as modules even if it doesn't use import/export
 		"moduleDetection": "force",
-
 		// Ignore module structure
 		"module": "Preserve",
-
 		// Allow JSON modules to be imported
 		"resolveJsonModule": true,
-
 		// Allow JS files to be imported from TS and vice versa
 		"allowJs": true,
-
 		// Use correct ESM import behavior
 		"esModuleInterop": true,
-
 		// Disallow features that require cross-file awareness
 		"isolatedModules": true,
-
-    "baseUrl": "src",
-    "paths": {
-      "*": ["*"]
-    },
+		"baseUrl": ".",
+		"paths": {
+			"*": [
+				"src/*",
+				".hive/*",
+				"../hive/*"
+			],
+			"@hive": ["src/index"],
+			"@hive/*": ["src/*"],
+			"@/*": [
+				".hive/*",
+				"../hive/*"
+			],
+		}
 	},
- "include": [
+	"include": [
 		"src/**/*",
-		".hive/**/*"
+		".hive/**/*",
+		"../hive/**/*"
 	]
 }

package/package.json

@@ -1,71 +1,63 @@
 {
   "name": "@paralect/hive",
-  "version": "0.1.50-alpha.2",
+  "version": "0.1.50",
   "description": "",
   "main": "index.js",
   "bin": {
     "hive": "cli/hive.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test:init": "rm -rf test-app && node cli/hive.js init test-app --skip-install && cd test-app && npm pkg set 'dependencies.@paralect/hive=file:..' && npm install",
+    "test:dev": "cd test-app && npm run dev"
   },
   "dependencies": {
-    "@koa/cors": "3.1.0",
-    "@koa/multer": "3.0.0",
-    "@koa/router": "10.1.1",
-    "@paralect/node-mongo": "2.1.1",
-    "@react-email/components": "^0.0.20",
-    "@react-email/render": "^0.0.16",
-    "@sendgrid/mail": "7.6.1",
-    "@socket.io/redis-adapter": "7.1.0",
-    "@socket.io/redis-emitter": "4.1.1",
+    "@koa/cors": "5.0.0",
+    "@koa/multer": "4.0.0",
+    "@koa/router": "15.3.0",
+    "@react-email/components": "^1.0.7",
+    "@react-email/render": "^2.0.4",
+    "@socket.io/redis-adapter": "8.3.0",
+    "@socket.io/redis-emitter": "5.1.0",
     "app-module-path": "2.2.0",
-    "aws-sdk": "2.1080.0",
-    "axios": "^1.7.2",
-    "bcryptjs": "2.4.3",
-    "bullmq": "^5.10.3",
-    "commander": "^12.1.0",
-    "dotenv": "16.0.0",
-    "eslint-config-prettier": "8.5.0",
-    "execa": "^4.1.0",
-    "fs-extra": "^11.2.0",
-    "handlebars": "4.7.7",
-    "inquirer": "^8.2.6",
-    "joi": "^17.13.3",
-    "koa": "2.13.4",
-    "koa-bodyparser": "4.3.0",
-    "koa-helmet": "6.1.0",
-    "koa-logger": "3.2.1",
-    "koa-mount": "4.0.0",
+    "aws-sdk": "2.1693.0",
+    "axios": "^1.13.5",
+    "bullmq": "^5.69.1",
+    "commander": "^14.0.3",
+    "dotenv": "17.3.1",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.2.2",
+    "koa": "3.1.1",
+    "koa-bodyparser": "4.4.1",
+    "koa-helmet": "9.0.0",
+    "koa-logger": "4.0.0",
+    "koa-mount": "4.2.0",
     "koa-qs": "3.0.0",
-    "lodash": "4.17.21",
-    "mjml": "4.12.0",
-    "mkdirp": "^1.0.4",
-    "moment": "2.29.1",
+    "lodash": "4.17.23",
+    "mjml": "4.18.0",
+    "mkdirp": "3.0.1",
+    "moment": "2.30.1",
     "moment-duration-format": "2.3.2",
-    "multer": "1.4.4",
-    "node-schedule": "2.1.0",
-    "nodemailer": "^6.9.14",
-    "nodemon": "2.0.15",
-    "prettier": "2.6.2",
-    "psl": "1.8.0",
-    "redis": "3.1.2",
+    "monk": "^7.3.4",
+    "node-schedule": "2.1.1",
+    "nodemailer": "^8.0.1",
+    "nodemon": "3.1.11",
+    "prettier": "3.8.1",
+    "psl": "1.15.0",
+    "redis": "^5.10.0",
     "require-dir": "1.2.0",
-    "slug": "^9.1.0",
-    "socket.io": "4.4.1",
-    "socket.io-emitter": "3.2.0",
-    "tail": "2.2.4",
-    "tsx": "^4.16.2",
-    "typescript": "^5.5.4",
-    "winston": "3.6.0",
-    "zod": "^3.23.8"
+    "socket.io": "4.8.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "winston": "3.19.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "eslint": "8.9.0",
+    "eslint": "9.28.0",
     "eslint-config-airbnb-base": "15.0.0",
-    "eslint-plugin-import": "2.25.4",
-    "husky": "7.0.4",
-    "lint-staged": "12.3.4"
+    "eslint-plugin-import": "2.32.0",
+    "husky": "9.1.7",
+    "lint-staged": "16.2.7"
   },
   "keywords": [],
   "author": "",

package/starter/hive/autoMap/schemaMappings.json

@@ -0,0 +1 @@
+{}

package/starter/hive/config/.env.example

@@ -0,0 +1,11 @@
+PORT=3001
+
+WEB_URL=http://localhost:3002
+
+MONGODB_URI=mongodb://root:root@localhost:27017/hive-dev?authSource=admin&replicaSet=rs&tls=false&directConnection=true
+REDIS_URI=redis://:@localhost:6379
+
+# STORAGE_ENDPOINT=https://fra1.digitaloceanspaces.com
+# STORAGE_ACCESS_KEY_ID=youraccesskey
+# STORAGE_SECRET=yoursecretkey
+# STORAGE_BUCKET=yourbucket

package/starter/hive/config/app.ts

@@ -0,0 +1,19 @@
+export default {
+  _hive: {
+    authHeaderName: 'x-api-key',
+  },
+
+  webUrl: process.env.WEB_URL,
+
+  cloudStorage: {
+    endpoint: process.env.STORAGE_ENDPOINT,
+    accessKeyId: process.env.STORAGE_ACCESS_KEY_ID,
+    secretAccessKey: process.env.STORAGE_SECRET,
+    bucket: process.env.STORAGE_BUCKET
+  },
+
+  // google: {
+  //   clientId: process.env.GOOGLE_CLIENT_ID,
+  //   clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+  // },
+};

package/{.hive/src/services/setCookie.js → starter/hive/helpers/setCookie.ts}

@@ -1,7 +1,6 @@
 import psl from 'psl';
 import url from 'url';
-import { env } from 'app-config';
-import { webUri } from 'app-config';
+import { webUri } from '@hive/config';
 
 let cookiesDomain;
 

package/starter/hive/middlewares/_global.ts

@@ -0,0 +1,9 @@
+import isAuthorized from '@/middlewares/isAuthorized';
+
+export default async (ctx, next) => {
+  await isAuthorized(ctx, async () => {
+    // await someOtherMiddleware(ctx, next);
+
+    return next();
+  });
+};

package/{.hive/src/middlewares/attachUser.js → starter/hive/middlewares/attachUser.ts}

@@ -1,5 +1,5 @@
-import db from 'db';
-import config from 'app-config';
+import { db } from '@hive';
+import config from '@hive/config';
 
 const userService = db.services.users;
 const tokenService = db.services.tokens;

package/{.hive/src/middlewares/shouldExist.js → starter/hive/middlewares/shouldExist.ts}

@@ -1,4 +1,4 @@
-import db from 'db';
+import { db } from '@hive';
 
 function singularize(word) {
   const endings = {

package/{.hive/src/middlewares/shouldNotExist.js → starter/hive/middlewares/shouldNotExist.ts}

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import db from 'db';
+import { db } from '@hive';
 
 export default (
   resourceName,

package/starter/hive/resources/files/endpoints/upload.ts

@@ -0,0 +1,25 @@
+import { endpoint } from '@hive';
+import uploadFile from '@/middlewares/uploadFile';
+import cloudStorageService from '@/services/cloudStorage';
+
+export default endpoint({
+  method: 'post',
+  url: '/',
+  middlewares: [uploadFile.single('file')],
+
+  handler: async (ctx) => {
+    const { file } = ctx.request;
+    const fileName = `${Date.now()}-${file.originalname}`;
+
+    const data = await cloudStorageService.uploadPublic(
+      `hive/${ctx.state.user._id}/${fileName}`,
+      file
+    );
+
+    let { Location: url } = data;
+
+    ctx.body = {
+      url,
+    };
+  },
+});

package/starter/hive/resources/files/files.schema.ts

@@ -0,0 +1,20 @@
+import { z, dbSchema } from '@hive/schema';
+
+const schema = dbSchema.extend({
+  url: z.coerce.string().nullable(),
+
+  user: z
+    .object({
+      _id: z.string(),
+    })
+    .passthrough()
+    .nullable()
+    .optional(),
+
+  name: z.coerce.string().nullable().optional(),
+  description: z.coerce.string().nullable().optional(),
+});
+
+export default schema;
+
+export const secureFields = [];

package/{.hive/src/resources/tokens/methods/storeToken.js → starter/hive/resources/tokens/methods/storeToken.ts}

@@ -1,10 +1,10 @@
-import db from 'db';
 import crypto from 'crypto';
 import util from 'util';
 
-const randomBytes = util.promisify(crypto.randomBytes, crypto);
+import { db } from '@hive';
+import setCookie from '@/services/setCookie';
 
-import setCookie from 'services/setCookie';
+const randomBytes = util.promisify(crypto.randomBytes, crypto);
 
 const tokenService = db.services.tokens;
 

package/{.hive/src/resources/tokens/tokens.schema.js → starter/hive/resources/tokens/tokens.schema.ts}

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-import dbSchema from 'helpers/schema/db.schema';
+import { z, dbSchema } from '@hive/schema';
 
 export default dbSchema.extend({
   user: z.object({

package/starter/hive/resources/users/endpoints/getCurrentUser.ts

@@ -0,0 +1,12 @@
+import { endpoint } from '@hive';
+import isAuthorized from '@/middlewares/isAuthorized';
+
+export default endpoint({
+  method: 'get',
+  url: '/me',
+  middlewares: [isAuthorized],
+
+  handler: async (ctx) => {
+    ctx.body = ctx.state.user;
+  },
+});

package/starter/hive/resources/users/endpoints/getUserProfile.ts

@@ -0,0 +1,17 @@
+import { endpoint, z, db } from '@hive';
+
+const userService = db.services.users;
+
+export default endpoint({
+  method: 'get',
+  url: '/profile/:userId',
+
+  requestSchema: z.object({
+    userId: z.string(),
+  }),
+
+  handler: async (ctx) => {
+    const user = await userService.findOne({ _id: ctx.params.userId });
+    ctx.body = user;
+  },
+});

package/{.hive/src/resources/users/users.schema.js → starter/hive/resources/users/users.schema.ts}

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-import dbSchema from 'helpers/schema/db.schema';
+import { z, dbSchema } from '@hive/schema';
 
 const users = dbSchema.extend({
   email: z.string().email(),

package/starter/hive/services/cloudStorage.ts

@@ -0,0 +1,102 @@
+import AWS from 'aws-sdk';
+import axios from 'axios';
+import config from '@/config/app';
+
+const Bucket = config.cloudStorage.bucket;
+const spacesEndpoint = config.cloudStorage.secretAccessKey ? new AWS.Endpoint(config.cloudStorage.endpoint) : null;
+
+const storage = config.cloudStorage.secretAccessKey ? new AWS.S3({
+  endpoint: spacesEndpoint,
+  accessKeyId: config.cloudStorage.accessKeyId,
+  secretAccessKey: config.cloudStorage.secretAccessKey,
+}) : null;
+
+function getSignedUrl(fileName) {
+  const params = {
+    Bucket,
+    Key: fileName,
+    Expires: 1800,
+  };
+
+  return storage.getSignedUrl('getObject', params);
+}
+
+function upload(filePath, file) {
+  const params = {
+    Bucket,
+    ContentType: file.mimetype,
+    Body: file.buffer,
+    Key: filePath,
+    ACL: 'private',
+  };
+
+  return storage.upload(params).promise();
+}
+
+function uploadPublic(filePath, file) {
+  const params = {
+    Bucket,
+    ContentType: file.mimetype,
+    Body: file.buffer,
+    Key: filePath,
+    ACL: 'public-read',
+  };
+
+  return storage.upload(params).promise();
+}
+
+function uploadStream(filePath, stream, contentType, isPublic = false) {
+  const params = {
+    Bucket,
+    ContentType: contentType,
+    Body: stream,
+    Key: filePath,
+    ACL: isPublic ? 'public-read' : 'private',
+  };
+
+  return storage.upload(params).promise();
+}
+
+async function uploadFromUrl(filePath, url, headers = {}, isPublic = false) {
+  console.log('getting image', filePath, url, headers);
+  const response = await axios({
+    method: 'get',
+    url: url,
+    headers: headers,
+    responseType: 'stream',
+  });
+
+  const contentType =
+    response.headers['content-type'] || 'application/octet-stream';
+
+  return uploadStream(filePath, response.data, contentType, isPublic);
+}
+
+function copy(filePath, copyFilePath) {
+  const params = {
+    Bucket,
+    CopySource: `${Bucket}/${copyFilePath}`,
+    Key: filePath,
+  };
+
+  return storage.copyObject(params).promise();
+}
+
+function remove(filePath) {
+  const params = {
+    Bucket,
+    Key: filePath,
+  };
+
+  return storage.deleteObject(params).promise();
+}
+
+export default {
+  getSignedUrl,
+  copy,
+  upload,
+  uploadPublic,
+  remove,
+  uploadStream,
+  uploadFromUrl,
+};