@fireberry/cli 0.0.5-beta.9 → 0.2.1

package/src/utils/components.utils.ts

@@ -4,14 +4,24 @@ import yaml from "js-yaml";
 import chalk from "chalk";
 import * as tar from "tar";
 import os from "node:os";
-import { Manifest, ManifestComponent, ZippedComponent } from "../api/types.js";
+import {
+  Manifest,
+  ZippedComponent,
+  UntypedManifestComponent,
+  RecordComponentSettings,
+  GlobalMenuComponentSettings,
+  SideMenuComponentSettings,
+} from "../api/types.js";
+import { COMPONENT_TYPE } from "../constants/component-types.js";
+import { HEIGHT_OPTIONS } from "../constants/height-options.js";
 
-export const getManifest = async (): Promise<Manifest> => {
-  const manifestPath = path.join(process.cwd(), "manifest.yml");
+export const getManifest = async (basePath?: string): Promise<Manifest> => {
+  const manifestPath = path.join(basePath || process.cwd(), "manifest.yml");
+  const searchDir = basePath || process.cwd();
 
   if (!(await fs.pathExists(manifestPath))) {
     throw new Error(
-      `No manifest.yml found at ${chalk.yellow(process.cwd())}.\n` +
+      `No manifest.yml found at ${chalk.yellow(searchDir)}.\n` +
         `Please run this command from your Fireberry app directory.`
     );
   }
@@ -33,9 +43,147 @@ export const getManifest = async (): Promise<Manifest> => {
   return manifest;
 };
 
+const validateRecordComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<RecordComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required settings`
+    );
+  }
+
+  const requiredFields: (keyof RecordComponentSettings)[] = [
+    "iconName",
+    "iconColor",
+    "objectType",
+    "height",
+  ];
+
+  for (const fieldName of requiredFields) {
+    if (settings[fieldName] === undefined || settings[fieldName] === null) {
+      throw new Error(
+        `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required setting: ${fieldName}`
+      );
+    }
+  }
+
+  if (typeof settings.iconName !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconName" must be a string`
+    );
+  }
+
+  if (typeof settings.iconColor !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconColor" must be a string`
+    );
+  }
+
+  if (typeof settings.objectType !== "number") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "objectType" must be a number`
+    );
+  }
+  if (!settings.height) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`
+    );
+  }
+
+  if (!HEIGHT_OPTIONS.includes(settings.height as any)) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`
+    );
+  }
+};
+
+const validateGlobalMenuComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<GlobalMenuComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required settings`
+    );
+  }
+
+  if (!settings.displayName) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required setting: displayName`
+    );
+  }
+
+  if (typeof settings.displayName !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) setting "displayName" must be a string`
+    );
+  }
+};
+
+const validateSideMenuComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<SideMenuComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) is missing required settings`
+    );
+  }
+
+  if (!settings.icon) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "icon" must be a string`
+    );
+  }
+
+  if (!settings.width) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`
+    );
+  }
+
+  if (
+    settings.width !== "S" &&
+    settings.width !== "M" &&
+    settings.width !== "L"
+  ) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`
+    );
+  }
+};
+
+const validateComponentSettings = (comp: UntypedManifestComponent): void => {
+  switch (comp.type) {
+    case COMPONENT_TYPE.RECORD:
+      validateRecordComponentSettings(comp);
+      break;
+    case COMPONENT_TYPE.GLOBAL_MENU:
+      validateGlobalMenuComponentSettings(comp);
+      break;
+    case COMPONENT_TYPE.SIDE_MENU:
+      validateSideMenuComponentSettings(comp);
+      break;
+    default:
+      throw new Error(
+        `Component "${comp.title}" has unsupported type: ${comp.type}. Supported types: ${COMPONENT_TYPE.RECORD}, ${COMPONENT_TYPE.GLOBAL_MENU}`
+      );
+  }
+};
+
 export const validateComponentBuild = async (
   componentPath: string,
-  comp: ManifestComponent
+  comp: UntypedManifestComponent
 ) => {
   if (!(await fs.pathExists(componentPath))) {
     throw new Error(
@@ -49,10 +197,13 @@ export const validateComponentBuild = async (
 
   if (stats.isDirectory()) {
     const files = await fs.readdir(componentPath);
+
     if (files.length === 0) {
-      throw new Error(`Component <${comp.key}> at: /${comp.path} not found`);
+      throw new Error(`Component <${comp.id}> at: /${comp.path} not found`);
     }
   }
+
+  validateComponentSettings(comp);
 };
 
 export const zipComponentBuild = async (
@@ -102,31 +253,42 @@ export const zipComponentBuild = async (
   }
 };
 
-export const handleComponents = async (
-  manifest: Manifest
-): Promise<ZippedComponent[]> => {
-  const components = manifest.components;
+export const validateManifestComponents = async (manifest: Manifest) => {
+  const components = manifest.components as unknown as
+    | UntypedManifestComponent[]
+    | undefined;
   if (!components || components.length === 0) {
-    return [];
+    throw new Error("No components found in manifest");
+  }
+
+  const ids = components.map((comp) => comp.id);
+  if (new Set(ids).size !== ids.length) {
+    throw new Error("All component ids must be unique");
   }
 
-  const keys = components.map((comp) => comp.key);
-  if (new Set(keys).size !== keys.length) {
-    throw new Error("All component keys must be unique");
+  for (const comp of components) {
+    const componentPath = path.join(process.cwd(), comp.path);
+    await validateComponentBuild(componentPath, comp);
   }
+};
+
+export const handleComponents = async (
+  manifest: Manifest
+): Promise<ZippedComponent[]> => {
+  await validateManifestComponents(manifest);
+  const components =
+    manifest.components as unknown as UntypedManifestComponent[];
 
   const zippedComponents: ZippedComponent[] = [];
 
   for (const comp of components) {
     const componentPath = path.join(process.cwd(), comp.path);
 
-    await validateComponentBuild(componentPath, comp);
-
     const buildBuffer = await zipComponentBuild(componentPath, comp.title);
 
     zippedComponents.push({
       title: comp.title,
-      key: comp.key,
+      id: comp.id,
       build: buildBuffer,
     });
   }