rapida-partner 1.0.0

package/src/utils/json.ts

@@ -0,0 +1,100 @@
+import * as fs from "fs";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { schemasPath } from "./path";
+
+const ajv = new Ajv({ strict: false });
+addFormats(ajv); // Add formats like "date", "email", etc.
+
+const addedSchemas = new Set<string>();
+
+const getJsonFile = (filePath: string): any => {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error: any) {
+    console.error(`Error reading file from path: ${filePath}`, error);
+    return null;
+  }
+};
+
+const validateProjectJson = (
+  jsonProjectInstance: any,
+  jsonSchemaName: string
+): boolean => {
+  try {
+    const jsonSchemaInstance = getJsonFile(
+      `${schemasPath}/${jsonSchemaName}.schema.json`
+    );
+
+    if (!jsonSchemaInstance) {
+      throw new Error(`Schema ${jsonSchemaName} not found`);
+    }
+
+    const refs: string[] = [];
+    const jsonProjectObject = JSON.parse(jsonProjectInstance);
+
+    groupJsonSchemaRefs(jsonSchemaInstance, refs);
+
+    if (refs.length > 0) {
+      addRefsToSchema(refs);
+    }
+
+    const validate = ajv.compile(jsonSchemaInstance);
+    const valid = validate(jsonProjectObject);
+
+    if (!valid) {
+      console.info(validate.errors);
+      return false;
+    }
+
+    console.info("Project JSON is valid");
+
+    return true;
+  } catch (error: any) {
+    console.error(error);
+    return false;
+  }
+};
+
+const groupJsonSchemaRefs = (obj: any, refs: string[]): void => {
+  if (typeof obj === "object" && obj !== null) {
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        groupJsonSchemaRefs(item, refs);
+      }
+    } else {
+      for (const key in obj) {
+        if (key === "$ref" && typeof obj[key] === "string") {
+          refs.push(obj[key]);
+        } else {
+          groupJsonSchemaRefs(obj[key], refs);
+        }
+      }
+    }
+  }
+};
+
+const addRefsToSchema = (refs: string[]) => {
+  const newRefs: string[] = [];
+
+  refs.forEach((ref) => {
+    const refContent = getJsonFile(`${schemasPath}/${ref}`);
+
+    if (!addedSchemas.has(ref)) {
+      groupJsonSchemaRefs(refContent, newRefs);
+
+      if (refContent) {
+        ajv.addSchema(refContent, refContent["$id"]);
+        addedSchemas.add(ref);
+      } else {
+        throw new Error(`Referenced schema ${ref} not found`);
+      }
+    }
+  });
+
+  if (newRefs.length > 0) {
+    addRefsToSchema(newRefs);
+  }
+};
+
+export { getJsonFile, validateProjectJson };

package/src/utils/path.ts

@@ -0,0 +1,51 @@
+import * as chp from 'child_process';
+
+import * as path from 'path';
+import { rootPath } from './env';
+
+/** 
+ * Apps paths 
+ */
+const appsPath = path.join(rootPath!, 'rapida-apps');
+const examplesPath = path.join(rootPath!, 'src', 'examples');
+const modelsPath = path.join(rootPath!, 'src', 'models');
+const schemasPath = path.join(rootPath!, 'src', 'schemas');
+const scriptsPath = path.join(rootPath!, 'src', 'scripts');
+
+/** 
+ * Rapida's paths 
+ */
+const frontendFrameworkStructuresPath = path.join(
+  rootPath!,
+  'models',
+  'frontend',
+  'json',
+  'frontend-framework-structures'
+);
+const backendFrameworkStructuresPath = path.join(
+  rootPath!,
+  'models',
+  'backend',
+  'json',
+  'backend-framework-structures'
+);
+
+const doesDirectoryExist = (directoryPath: string): boolean => {
+  try {
+    chp.execSync(`ls ${directoryPath}`, { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export {
+  appsPath,
+  examplesPath,
+  modelsPath,
+  schemasPath,
+  scriptsPath,
+  frontendFrameworkStructuresPath,
+  backendFrameworkStructuresPath,
+  doesDirectoryExist
+};

package/src/utils/rapida-project.ts

@@ -0,0 +1,17 @@
+import type { IProject } from "../interfaces/project.interface";
+import { getJsonFile } from "./json";
+import { modelsPath } from "./path";
+
+const getProjectJson = (projectName: string) => {
+  try {
+    const jsonProject: IProject = getJsonFile(
+      `${modelsPath}/apps/${projectName}`
+    );
+
+    return jsonProject;
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+export { getProjectJson };

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}