@diamondslab/diamonds 1.0.0

package/src/repositories/FileDeploymentRepository.ts

@@ -0,0 +1,67 @@
+import { DeploymentRepository } from './DeploymentRepository';
+import { DeployedDiamondData, DeployConfig } from '../schemas';
+import { readDeployFile, writeDeployInfo, readDeployConfig } from './jsonFileHandler';
+import { DiamondConfig } from '../types';
+import { join } from 'path';
+import chalk from 'chalk';
+
+export class FileDeploymentRepository implements DeploymentRepository {
+  private deploymentDataPath: string;
+  private deployedDiamondDataFilePath: string;
+  private configFilePath: string;
+  private writeDeployedDiamondData: boolean;
+  private deploymentId: string;
+
+  constructor(config: DiamondConfig) {
+    this.deploymentDataPath = config.deploymentsPath! || 'diamonds';
+    this.writeDeployedDiamondData = config.writeDeployedDiamondData ?? true;
+    this.deploymentId = `${config.diamondName.toLowerCase()}-${config.networkName!.toLowerCase()}-${config.chainId!.toString()}`;
+
+    if (config.deployedDiamondDataFilePath) {
+      this.deployedDiamondDataFilePath = config.deployedDiamondDataFilePath;
+    } else {
+      this.deployedDiamondDataFilePath = join(
+        this.deploymentDataPath,
+        config.diamondName,
+        `deployments/${this.deploymentId}.json`
+      )
+    }
+    if (config.configFilePath) {
+      this.configFilePath = config.configFilePath;
+    } else {
+      this.configFilePath = join(
+        this.deploymentDataPath,
+        config.diamondName,
+        `${config.diamondName.toLowerCase()}.config.json`
+      );
+    }
+  }
+
+  public setWriteDeployedDiamondData(write: boolean): void {
+    this.writeDeployedDiamondData = write;
+  }
+
+  public getWriteDeployedDiamondData(): boolean {
+    return this.writeDeployedDiamondData;
+  }
+
+  loadDeployedDiamondData(): DeployedDiamondData {
+    return readDeployFile(this.deployedDiamondDataFilePath, this.writeDeployedDiamondData);
+  }
+
+  saveDeployedDiamondData(info: DeployedDiamondData): void {
+    if (this.writeDeployedDiamondData) {
+      writeDeployInfo(this.deployedDiamondDataFilePath, info);
+    } else {
+      console.log(chalk.cyanBright("Skipping write of diamond deployment data. Set writeDeployedDiamondData to true to enable."));
+    }
+  }
+
+  loadDeployConfig(): DeployConfig {
+    return readDeployConfig(this.configFilePath);
+  }
+
+  public getDeploymentId(): string {
+    return this.deploymentId;
+  }
+}

package/src/repositories/databaseHandler.ts

@@ -0,0 +1,14 @@
+// import { DeployedDiamondData, DeployConfig } from "../schemas";
+
+// // This would internally use your chosen DB driver (e.g. pg, Prisma, TypeORM)
+// export async function readDeployedDiamondData(network: string, diamond: string): Promise<DeployedDiamondData> {
+//   // SQL or ORM call here
+// }
+
+// export async function saveDeploymentInfo(network: string, diamond: string, info: DeployedDiamondData): Promise<void> {
+//   // SQL or ORM upsert
+// }
+
+// export async function getDeployConfigData(projectId: string): Promise<DeployConfig> {
+//   // SQL or ORM fetch
+// }

package/src/repositories/index.ts

@@ -0,0 +1,4 @@
+export * from "./DeploymentRepository";
+export * from "./FileDeploymentRepository";
+export * from "./jsonFileHandler";
+

package/src/repositories/jsonFileHandler.ts

@@ -0,0 +1,252 @@
+/**
+ * CRUD and validation helpers for JSON files
+ * 
+ * These should all be synchronous and handle issues like empty files or non-existent files
+ * gracefully in a way that allows for control by the caller, e.g. gives the caller the
+ * ability to create an empty file on failure.
+ */
+
+import {
+  ensureFileSync,
+  existsSync,
+  pathExistsSync,
+  readJsonSync,
+  removeSync,
+  writeJsonSync
+} from "fs-extra";
+import { join, resolve } from "path";
+import {
+  DeployConfig,
+  DeployConfigSchema,
+  DeployedDiamondData,
+  DeployedDiamondDataSchema
+} from "../schemas/DeploymentSchema";
+
+export function readDeployFilePathDiamondNetwork(
+  networkName: string,
+  diamondName: string,
+  deploymentId: string,
+  deploymentsPath: string,
+  createNew: boolean = false
+): DeployedDiamondData {
+  const filePath = join(deploymentsPath, diamondName, `${deploymentId}.json`);
+  return readDeployFile(filePath, createNew);
+}
+
+/**
+ * Reads and validates a JSON file as DeployedDiamondData
+ * @param path - The path to the deployment file.
+ * @param createIfMissing - If true, creates a new deployment file with default values if 
+ * the file does not exist. Otherwise this will throw an error if the file does not exist.
+ * @returns The parsed and validated deployment object.
+ */
+export function readDeployFile(path: string, createNew: boolean = true)
+  : DeployedDiamondData {
+  let raw: unknown;
+  if (!pathExistsSync(path) && createNew) {
+    createNewDeployFile(path);
+    raw = readJsonSync(path);
+
+    const parsed = DeployedDiamondDataSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`Invalid deployment format: ${JSON.stringify(parsed.error.format(), null, 2)}`);
+    }
+
+    return parsed.data;
+  } else if (pathExistsSync(path)) {
+    raw = readJsonSync(path);
+    const parsed = DeployedDiamondDataSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`Invalid deployment format: ${JSON.stringify(parsed.error.format(), null, 2)}`);
+    }
+    return parsed.data;
+  }
+
+  // This is a mock deployment object with empty values
+  return defaultDeployment();
+}
+
+/**
+ * Resolves the absolute path of a file relative to the project root.
+ * @param relativePath - The relative path to resolve.
+ * @returns The absolute path.
+ */
+const resolvePath = (relativePath: string): string => {
+  return resolve(process.cwd(), relativePath);
+};
+
+/**
+ * Default deployment object with empty values
+ * This is used to create a new deployment file if it does not exist or for a mock deployment.
+ * @type {DeployedDiamondData}
+ */
+export function defaultDeployment(): DeployedDiamondData {
+  return {
+    DiamondAddress: "",
+    DeployerAddress: "",
+    DeployedFacets: {}, // Empty object for facets
+    ExternalLibraries: {}, // Empty object for external libraries
+    protocolVersion: 0, // Default protocol version
+  };
+}
+/**
+ * Creates a new deployment file with default empty values
+ * @param path - The path to the deployment file.
+ */
+export function createNewDeployFile(path: string) {
+  // Ensure the directory exists before writing
+  ensureFileSync(path);
+  // Validate the default deployment object before writing
+  const validated = DeployedDiamondDataSchema.parse(defaultDeployment());
+  writeJsonSync(path, validated, { spaces: 2 });
+}
+
+/**
+ * Writes JSON to file
+ */
+export function writeDeployInfo(path: string, data: DeployedDiamondData) {
+  const validated = DeployedDiamondDataSchema.parse(data);
+  writeJsonSync(path, validated, { spaces: 2 });
+}
+
+/**
+ * Update deployment JSON file
+ */
+export function updateDeployInfo(path: string, updater: (data: DeployedDiamondData) => void) {
+  const data = readDeployFile(path);
+  updater(data);
+  writeDeployInfo(path, data);
+}
+
+/**
+ * Deletes the deployment file
+ */
+export function deleteDeployInfo(path: string) {
+  if (pathExistsSync(path)) {
+    removeSync(path);
+  }
+}
+
+/**
+ * Validates the Deployment File without loading it.
+ * @param path 
+ * @returns 
+ */
+export function validateDeployFile(path: string): boolean {
+  try {
+    if (!pathExistsSync(path)) {
+      console.log(`Deployment file not found: ${path}`);
+      return false;
+    }
+    const raw = readJsonSync(path);
+    DeployedDiamondDataSchema.parse(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function loadFacetsConfig(
+  deploymentsPath: string,
+  diamondName: string
+): DeployConfig {
+  const file = join(deploymentsPath, diamondName, `${diamondName}.config.json`);
+  const valid = validateDeployConfig(file);
+
+  const facets = readDeployConfig(file);
+  return facets;
+}
+
+/**
+ * Loads and validates the facets config <diamondName>.config.json file.
+ * @param filePath - The path to the facets file.
+ * @returns The parsed and validated facets object.
+ */
+export const readDeployConfig = (filePath: string): DeployConfig => {
+  try {
+    const fullPath = resolvePath(filePath);
+
+    // Read the JSON file
+    const raw = readJsonSync(fullPath);
+
+    // Validate and parse the JSON data
+    return DeployConfigSchema.parse(raw);
+  } catch (e) {
+    console.error('Failed to load facets:', e);
+    throw e;
+  }
+};
+
+/**
+ * Saves the Diamond Config object to a file.
+ * @param filePath - The path to the facets file.
+ * @param data - The facets object to save.
+ */
+export const saveDeployConfig = (filePath: string, data: DeployConfig): void => {
+  const fullPath = resolvePath(filePath);
+  ensureFileSync(fullPath);
+  writeJsonSync(fullPath, data, { spaces: 2 });
+};
+
+/**
+ * Updates a specific facet in the facets file.
+ * @param filePath - The path to the facets file.
+ * @param facetKey - The key of the facet to update.
+ * @param update - The partial update to apply to the facet.
+ * @returns The updated facets object.
+ */
+export const updateFacetConfig = (
+  filePath: string,
+  facetKey: string,
+  update: Partial<DeployConfig["facets"][string]>
+): DeployConfig => {
+  const deployConfig = readDeployConfig(filePath);
+  deployConfig.facets[facetKey] = {
+    ...(deployConfig.facets[facetKey] || {}),
+    ...update,
+  };
+  saveDeployConfig(filePath, deployConfig);
+  return deployConfig;
+};
+
+/**
+ * Deletes a specific facet from the facets file.
+ * @param filePath - The path to the facets file.
+ * @param facetKey - The key of the facet to delete.
+ * @returns The updated facets object.
+ */
+export const deleteFacet = (filePath: string, facetKey: string): DeployConfig => {
+  const deployConfig = readDeployConfig(filePath);
+  delete deployConfig.facets[facetKey];
+  saveDeployConfig(filePath, deployConfig);
+  return deployConfig;
+};
+
+/**
+ * Validates that the facets file exists, is valid JSON, and conforms to the schema.
+ * @param filePath - The path to the facets file.
+ * @returns A boolean indicating whether the file is valid.
+ */
+export const validateDeployConfig = (filePath: string): boolean => {
+  try {
+    const fullPath = resolvePath(filePath);
+
+    // Check if the file exists
+    if (!existsSync(fullPath)) {
+      console.error(`Validation failed: File does not exist at path "${filePath}"`);
+      return false;
+    }
+
+    // Read the file and parse it as JSON
+    const raw = readJsonSync(fullPath);
+
+    // Validate the JSON against the schema
+    DeployConfigSchema.parse(raw);
+
+    // If all checks pass, return true
+    return true;
+  } catch (e) {
+    console.error('Validation failed:', e);
+    return false;
+  }
+}

package/src/repositories/prismaDBHandler.ts

@@ -0,0 +1,10 @@
+// // databaseHandler.ts (Prisma example)
+// import { prisma } from './prisma';
+// import { DeployedDiamondData, DeployConfig } from '../schemas';
+
+// export async function readDeployedDiamondData(network: string, diamond: string): Promise<DeployedDiamondData> {
+//   const record = await prisma.deployment.findUnique({
+//     where: { network_diamond: { network, diamond } }
+//   });
+//   return record?.info as DeployedDiamondData;
+// }

package/src/schemas/DeploymentSchema.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+
+// Schema for a single facet's deployment information
+export const DeployedFacetSchema = z.object({
+	address: z.string().optional(), // Address of the deployed facet
+	tx_hash: z.string().optional(), // Transaction hash of the deployment
+	version: z.number().optional(), // Version of the facet
+	funcSelectors: z.array(z.string()).optional(), // Function selectors for the facet
+	verified: z.boolean().optional(), // Whether the facet is verified
+});
+
+// Schema for all deployed facets
+export const DeployedFacetsSchema = z.record(z.string(), DeployedFacetSchema);
+
+// Schema for external libraries
+export const ExternalLibrariesSchema = z.record(z.string(), z.string());
+
+// Schema for the network deployment information
+export const DeployedDiamondDataSchema = z.object({
+	DiamondAddress: z.string().optional(), // Address of the deployed diamond
+	DeployerAddress: z.string().optional(), // Address of the deployer
+	// FacetDeployedInfo: FacetDeployedInfoRecordSchema.optional(), // Information about deployed facets
+	DeployedFacets: DeployedFacetsSchema.optional(), // Information about deployed facets
+	ExternalLibraries: ExternalLibrariesSchema.optional(), // External libraries used in the deployment
+	protocolVersion: z.number().optional(), // Protocol version
+});
+
+/**
+ * Schema for the version information of a facet configuration to be deployed
+ */
+export const FacetVersionConfigSchema = z.object({
+	deployInit: z.string().optional(),
+	upgradeInit: z.string().optional(),
+	fromVersions: z.array(z.number()).optional(),
+	callbacks: z.array(z.string()).optional(),
+	deployInclude: z.array(z.string()).optional(),
+	deployExclude: z.array(z.string()).optional(),
+});
+
+/**
+ * Schema for the deployment information of a single facet
+ */
+export const FacetConfigSchema = z.object({
+	// Infer TypeScript types from schemas
+	priority: z.number(),
+	libraries: z.array(z.string()).optional(),
+	versions: z.record(z.string(), FacetVersionConfigSchema).optional(),
+});
+
+/**
+ * Schema for the deployment configuration information of ALL facets to be deployed
+ */
+export const FacetsConfigSchema = z.record(z.string(), FacetConfigSchema);
+
+export const DeployConfigSchema = z.object({
+	protocolVersion: z.number(),
+	protocolInitFacet: z.string().optional(),
+	protocolCallback: z.string().optional(),
+	facets: z.record(z.string(), FacetConfigSchema),
+});
+
+// Inferred types from Zod schemas
+export type FacetVersionConfig = z.infer<typeof FacetVersionConfigSchema>;
+export type FacetConfig = z.infer<typeof FacetConfigSchema>;
+export type FacetsConfig = z.infer<typeof FacetsConfigSchema>;
+export type DeployConfig = z.infer<typeof DeployConfigSchema>;
+
+// export type FacetsDeployment = z.infer<typeof FacetsConfigSchema>;
+export type DeployedFacet = z.infer<typeof DeployedFacetSchema>;
+export type DeployedFacets = z.infer<typeof DeployedFacetsSchema>;
+export type DeployedDiamondData = z.infer<typeof DeployedDiamondDataSchema>;

package/src/schemas/index.ts

@@ -0,0 +1 @@
+export * from './DeploymentSchema';