@bike4mind/cli 0.1.0

package/dist/chunk-LM6ZFZT6.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  BadRequestError,
+  checkStorageLimitForFile,
+  getFileExtension,
+  getMimeTypeByExtension,
+  getSettingsMap,
+  getSettingsValue,
+  secureParameters
+} from "./chunk-JVPB6BB5.js";
+import {
+  KnowledgeType,
+  SupportedFabFileMimeTypes
+} from "./chunk-MKO2KCCS.js";
+
+// ../../b4m-core/packages/services/dist/src/fabFileService/create.js
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+var createFabFileSchema = z.object({
+  fileName: z.string(),
+  mimeType: z.string(),
+  fileSize: z.number(),
+  type: z.nativeEnum(KnowledgeType),
+  content: z.union([z.string(), z.instanceof(Buffer)]).optional(),
+  organizationId: z.string().optional(),
+  /**
+   * Content type of the file
+   * @example 'text/markdown'
+   * @example 'application/pdf'
+   * @example 'application/octet-stream' for binary files
+   */
+  contentType: z.string().optional(),
+  public: z.boolean().optional(),
+  prefix: z.string().optional(),
+  system: z.boolean().optional(),
+  tags: z.array(z.object({ name: z.string(), strength: z.number() })).optional(),
+  systemPriority: z.number().optional(),
+  sessionId: z.string().optional()
+});
+var DEFAULT_MAX_FILE_SIZE = 20;
+var DEFAULT_EXPIRE_IN_SECONDS = 3600 * 24 * 5;
+var createFabFile = async (userId, parameters, { db, storage }) => {
+  const params = secureParameters(parameters, createFabFileSchema);
+  const user = await db.users.findById(userId);
+  if (!user)
+    throw new BadRequestError("User not found");
+  let ext = "";
+  let mimeType = parameters.mimeType;
+  ext = getFileExtension(params.fileName);
+  mimeType = params.mimeType || getMimeTypeByExtension(ext);
+  if (!mimeType) {
+    mimeType = SupportedFabFileMimeTypes.TXT_PLAIN;
+  }
+  if (!Object.values(SupportedFabFileMimeTypes).some((type) => type === mimeType)) {
+    throw new BadRequestError(`File type ${mimeType} is not supported`);
+  }
+  let filePath = params.prefix ? `${params.prefix}/` : "";
+  filePath += `${uuidv4()}${ext ? `.${ext}` : ".txt"}`;
+  const maxFileSize = getSettingsValue("MaxFileSize", await getSettingsMap(db), DEFAULT_MAX_FILE_SIZE) * 1024 * 1024;
+  if (params.fileSize >= maxFileSize)
+    throw new BadRequestError("File size exceeds maximum file size");
+  await checkStorageLimitForFile(user, params.fileSize, params.organizationId, db.organizations?.findById);
+  const buildData = {
+    userId,
+    ...params,
+    mimeType,
+    filePath,
+    users: [],
+    groups: [],
+    isGlobalRead: false,
+    isGlobalWrite: false,
+    createdAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  };
+  if (params.content) {
+    await storage.upload(filePath, params.content, {
+      ContentType: params.contentType,
+      ContentLength: params.fileSize
+    });
+    buildData.fileUrl = await storage.generateSignedUrl(filePath, DEFAULT_EXPIRE_IN_SECONDS, "get");
+    buildData.fileUrlExpireAt = new Date(Date.now() + DEFAULT_EXPIRE_IN_SECONDS * 1e3);
+  } else {
+    buildData.presignedUrl = await storage.generateSignedUrl(filePath, 600, "put");
+  }
+  const result = await db.fabFiles.create(buildData);
+  return result;
+};
+
+export {
+  createFabFileSchema,
+  createFabFile
+};