@embrace-ai/infra-api-schema-sync 1.0.6 → 1.0.8

package/src/update-local-schema.js

@@ -0,0 +1,216 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import fse from "fs-extra";
+import path from "path";
+
+import { extractServiceFromUrl } from "./generate-schema-url.js";
+
+/**
+ * Find all schema.graphql files in directories matching the service name
+ * @param {string} serviceName - Service name to search for
+ * @param {string} rootDir - Root directory to search from (default: cwd)
+ * @returns {string[]} Array of file paths
+ */
+const findSchemaFiles = (serviceName, rootDir = process.cwd()) => {
+  if (!serviceName) {
+    console.log("⚠️  No service name provided, skipping schema file search");
+    return [];
+  }
+
+  console.log(
+    `🔍 Searching for schema files in directories matching: ${serviceName}`,
+  );
+
+  try {
+    // Use find command to search for schema.graphql files in directories containing the service name
+    // This is more efficient than using a glob library for deep directory searches
+    const findCommand = `find . -type d -name "*${serviceName}*" -exec find {} -maxdepth 10 -name "schema.graphql" \\; 2>/dev/null || true`;
+
+    const output = execSync(findCommand, {
+      cwd: rootDir,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+    });
+
+    // Parse output and clean up paths
+    const files = output
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+      .map((line) => line.replace(/^\.\//, "")) // Remove leading ./
+      .filter(
+        (file) =>
+          // Exclude node_modules, dist, and other build directories
+          !file.includes("node_modules") &&
+          !file.includes("/dist/") &&
+          !file.includes("/.git/") &&
+          !file.includes("/build/") &&
+          !file.includes("/coverage/"),
+      );
+
+    // Remove duplicates
+    const uniqueFiles = [...new Set(files)];
+
+    if (uniqueFiles.length > 0) {
+      console.log(`✅ Found ${uniqueFiles.length} schema file(s):`);
+      uniqueFiles.forEach((file) => console.log(`   - ${file}`));
+    } else {
+      console.log(
+        `ℹ️  No schema files found in directories matching: ${serviceName}`,
+      );
+    }
+
+    return uniqueFiles;
+  } catch (error) {
+    console.warn(`⚠️  Error searching for schema files: ${error.message}`);
+    return [];
+  }
+};
+
+/**
+ * Update a schema file with new content
+ * @param {string} filePath - Path to the schema file
+ * @param {string} newContent - New schema content
+ * @returns {boolean} True if file was updated (content changed)
+ */
+const updateSchemaFile = (filePath, newContent) => {
+  try {
+    // Check if file exists and read current content
+    let currentContent = "";
+    if (fs.existsSync(filePath)) {
+      currentContent = fs.readFileSync(filePath, "utf8");
+    }
+
+    // Compare content (trim to ignore trailing whitespace differences)
+    if (currentContent.trim() === newContent.trim()) {
+      console.log(`   ℹ️  No changes needed for: ${filePath}`);
+      return false;
+    }
+
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    fse.ensureDirSync(dir);
+
+    // Write new content
+    fs.writeFileSync(filePath, newContent, "utf8");
+    console.log(`   ✅ Updated: ${filePath}`);
+    return true;
+  } catch (error) {
+    console.error(`   ❌ Failed to update ${filePath}: ${error.message}`);
+    return false;
+  }
+};
+
+/**
+ * Update local schema files based on schema URL
+ * @param {Object} options - Configuration options
+ * @param {string} options.schemaUrl - Schema URL to extract service name from
+ * @param {string} options.schemaFile - Path to the new schema file
+ * @param {string} options.output - JSON output file path
+ */
+export const updateLocalSchema = async ({ schemaUrl, schemaFile, output }) => {
+  try {
+    console.log("🔧 Starting local schema update process...");
+    console.log(`📡 Schema URL: ${schemaUrl}`);
+    console.log(`📄 New schema file: ${schemaFile}`);
+
+    // Extract service name from URL
+    const serviceName = extractServiceFromUrl(schemaUrl);
+
+    if (!serviceName) {
+      console.log(
+        "ℹ️  This is the main embrace API - no service-specific schema files to update",
+      );
+      const result = {
+        serviceName: "embrace",
+        updatedFiles: [],
+        hasChanges: false,
+        message:
+          "Main embrace API - no service-specific schema files to update",
+      };
+
+      // Write result to output file
+      if (output) {
+        fse.ensureDirSync(path.dirname(output));
+        fs.writeFileSync(output, JSON.stringify(result, null, 2), "utf8");
+        console.log(`📊 Result written to: ${output}`);
+      }
+
+      return result;
+    }
+
+    console.log(`🎯 Service name: ${serviceName}`);
+
+    // Read new schema content
+    if (!fs.existsSync(schemaFile)) {
+      throw new Error(`Schema file not found: ${schemaFile}`);
+    }
+    const newSchemaContent = fs.readFileSync(schemaFile, "utf8");
+
+    // Find schema files to update
+    const schemaFiles = findSchemaFiles(serviceName);
+
+    if (schemaFiles.length === 0) {
+      console.log("⚠️  No schema files found to update");
+      const result = {
+        serviceName,
+        updatedFiles: [],
+        hasChanges: false,
+        message: `No schema files found in directories matching: ${serviceName}`,
+      };
+
+      // Write result to output file
+      if (output) {
+        fse.ensureDirSync(path.dirname(output));
+        fs.writeFileSync(output, JSON.stringify(result, null, 2), "utf8");
+        console.log(`📊 Result written to: ${output}`);
+      }
+
+      return result;
+    }
+
+    // Update each schema file
+    console.log(`\n📝 Updating schema files...`);
+    const updatedFiles = [];
+    for (const file of schemaFiles) {
+      const wasUpdated = updateSchemaFile(file, newSchemaContent);
+      if (wasUpdated) {
+        updatedFiles.push(file);
+      }
+    }
+
+    const hasChanges = updatedFiles.length > 0;
+
+    console.log("");
+    if (hasChanges) {
+      console.log(`✅ Successfully updated ${updatedFiles.length} file(s)`);
+    } else {
+      console.log(`ℹ️  All schema files are already up to date`);
+    }
+
+    // Prepare result
+    const result = {
+      serviceName,
+      updatedFiles,
+      hasChanges,
+      message: hasChanges
+        ? `Updated ${updatedFiles.length} schema file(s)`
+        : "All schema files are already up to date",
+    };
+
+    // Write result to output file
+    if (output) {
+      fse.ensureDirSync(path.dirname(output));
+      fs.writeFileSync(output, JSON.stringify(result, null, 2), "utf8");
+      console.log(`📊 Result written to: ${output}`);
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`❌ Failed to update local schema: ${error.message}`);
+    throw error;
+  }
+};
+
+// Default export for CLI
+export default updateLocalSchema;

package/src/update-local-schema.test.js

@@ -0,0 +1,233 @@
+import fs from "fs";
+import fse from "fs-extra";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { extractServiceFromUrl } from "./generate-schema-url.js";
+import { updateLocalSchema } from "./update-local-schema.js";
+
+describe("extractServiceFromUrl", () => {
+  it("should extract service name from dev service URL", () => {
+    const url =
+      "https://api.integrations-plugins.services.dev.embrace.ai/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe("integrations-plugins");
+  });
+
+  it("should extract service name from prod service URL", () => {
+    const url =
+      "https://api.integrations-plugins.services.embrace.ai/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe("integrations-plugins");
+  });
+
+  it("should extract service name from PR service URL", () => {
+    const url =
+      "https://api.integrations-plugins.pr-123.services.dev.embrace.ai/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe("integrations-plugins");
+  });
+
+  it("should return null for main embrace API dev URL", () => {
+    const url = "https://api.dev.embrace.ai/v2/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe(null);
+  });
+
+  it("should return null for main embrace API PR URL", () => {
+    const url = "https://api.pr-123.dev.embrace.ai/v2/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe(null);
+  });
+
+  it("should handle multi-part service names", () => {
+    const url = "https://api.orgs-core.services.dev.embrace.ai/graphql/schema";
+    expect(extractServiceFromUrl(url)).toBe("orgs-core");
+  });
+});
+
+describe("updateLocalSchema", () => {
+  const testDir = path.join(process.cwd(), "test-temp-schema-update");
+  const schemaContent = `
+type Query {
+  hello: String
+}
+`.trim();
+
+  const updatedSchemaContent = `
+type Query {
+  hello: String
+  world: String
+}
+`.trim();
+
+  beforeEach(() => {
+    // Create test directory structure
+    fse.ensureDirSync(testDir);
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    if (fs.existsSync(testDir)) {
+      fse.removeSync(testDir);
+    }
+  });
+
+  it("should find and update schema files in matching directories", async () => {
+    // Create test structure
+    const serviceName = "integrations-plugins";
+    const schemaDir = path.join(
+      testDir,
+      "packages/core/src/services",
+      serviceName,
+    );
+    const schemaFile = path.join(schemaDir, "schema.graphql");
+
+    fse.ensureDirSync(schemaDir);
+    fs.writeFileSync(schemaFile, schemaContent, "utf8");
+
+    // Create new schema file
+    const newSchemaFile = path.join(testDir, "new-schema.graphql");
+    fs.writeFileSync(newSchemaFile, updatedSchemaContent, "utf8");
+
+    // Create output file path
+    const outputFile = path.join(testDir, "result.json");
+
+    // Run update
+    const result = await updateLocalSchema({
+      schemaUrl: `https://api.${serviceName}.services.dev.embrace.ai/graphql/schema`,
+      schemaFile: newSchemaFile,
+      output: outputFile,
+    });
+
+    // Verify result
+    expect(result.serviceName).toBe(serviceName);
+    expect(result.hasChanges).toBe(true);
+    expect(result.updatedFiles.length).toBeGreaterThan(0);
+
+    // Verify file was updated
+    const updatedContent = fs.readFileSync(schemaFile, "utf8");
+    expect(updatedContent.trim()).toBe(updatedSchemaContent);
+
+    // Verify output file was created
+    expect(fs.existsSync(outputFile)).toBe(true);
+    const outputData = JSON.parse(fs.readFileSync(outputFile, "utf8"));
+    expect(outputData.hasChanges).toBe(true);
+
+    // Verify the original schema file still exists (updated in place)
+    expect(fs.existsSync(schemaFile)).toBe(true);
+
+    // Verify the temporary input file still exists (not deleted by function)
+    expect(fs.existsSync(newSchemaFile)).toBe(true);
+  });
+
+  it("should detect when no changes are needed", async () => {
+    // Create test structure
+    const serviceName = "integrations-plugins";
+    const schemaDir = path.join(
+      testDir,
+      "packages/core/src/services",
+      serviceName,
+    );
+    const schemaFile = path.join(schemaDir, "schema.graphql");
+
+    fse.ensureDirSync(schemaDir);
+    fs.writeFileSync(schemaFile, schemaContent, "utf8");
+
+    // Create new schema file with same content
+    const newSchemaFile = path.join(testDir, "new-schema.graphql");
+    fs.writeFileSync(newSchemaFile, schemaContent, "utf8");
+
+    // Create output file path
+    const outputFile = path.join(testDir, "result.json");
+
+    // Run update
+    const result = await updateLocalSchema({
+      schemaUrl: `https://api.${serviceName}.services.dev.embrace.ai/graphql/schema`,
+      schemaFile: newSchemaFile,
+      output: outputFile,
+    });
+
+    // Verify result
+    expect(result.serviceName).toBe(serviceName);
+    expect(result.hasChanges).toBe(false);
+    expect(result.updatedFiles.length).toBe(0);
+
+    // Verify the original schema file still exists (unchanged)
+    expect(fs.existsSync(schemaFile)).toBe(true);
+
+    // Verify the temporary input file still exists (not deleted by function)
+    expect(fs.existsSync(newSchemaFile)).toBe(true);
+  });
+
+  it("should handle main embrace API (no service name)", async () => {
+    // Create new schema file
+    const newSchemaFile = path.join(testDir, "new-schema.graphql");
+    fs.writeFileSync(newSchemaFile, schemaContent, "utf8");
+
+    // Create output file path
+    const outputFile = path.join(testDir, "result.json");
+
+    // Run update with main API URL
+    const result = await updateLocalSchema({
+      schemaUrl: "https://api.dev.embrace.ai/v2/graphql/schema",
+      schemaFile: newSchemaFile,
+      output: outputFile,
+    });
+
+    // Verify result
+    expect(result.serviceName).toBe("embrace");
+    expect(result.hasChanges).toBe(false);
+    expect(result.updatedFiles.length).toBe(0);
+
+    // Verify the temporary input file still exists (not deleted by function)
+    expect(fs.existsSync(newSchemaFile)).toBe(true);
+  });
+
+  it("should handle multiple schema files in different directories", async () => {
+    // Create test structure with multiple schema files
+    const serviceName = "integrations-plugins";
+
+    const schemaDir1 = path.join(
+      testDir,
+      "packages/core/src/services",
+      serviceName,
+    );
+    const schemaFile1 = path.join(schemaDir1, "schema.graphql");
+
+    const schemaDir2 = path.join(testDir, "apps", serviceName, "graphql");
+    const schemaFile2 = path.join(schemaDir2, "schema.graphql");
+
+    fse.ensureDirSync(schemaDir1);
+    fse.ensureDirSync(schemaDir2);
+    fs.writeFileSync(schemaFile1, schemaContent, "utf8");
+    fs.writeFileSync(schemaFile2, schemaContent, "utf8");
+
+    // Create new schema file
+    const newSchemaFile = path.join(testDir, "new-schema.graphql");
+    fs.writeFileSync(newSchemaFile, updatedSchemaContent, "utf8");
+
+    // Create output file path
+    const outputFile = path.join(testDir, "result.json");
+
+    // Run update
+    const result = await updateLocalSchema({
+      schemaUrl: `https://api.${serviceName}.services.dev.embrace.ai/graphql/schema`,
+      schemaFile: newSchemaFile,
+      output: outputFile,
+    });
+
+    // Verify result
+    expect(result.serviceName).toBe(serviceName);
+    expect(result.hasChanges).toBe(true);
+    expect(result.updatedFiles.length).toBeGreaterThanOrEqual(1);
+
+    // Verify both files were updated
+    const updatedContent1 = fs.readFileSync(schemaFile1, "utf8");
+    const updatedContent2 = fs.readFileSync(schemaFile2, "utf8");
+    expect(updatedContent1.trim()).toBe(updatedSchemaContent);
+    expect(updatedContent2.trim()).toBe(updatedSchemaContent);
+
+    // Verify both original schema files still exist (updated in place)
+    expect(fs.existsSync(schemaFile1)).toBe(true);
+    expect(fs.existsSync(schemaFile2)).toBe(true);
+
+    // Verify the temporary input file still exists (not deleted by function)
+    expect(fs.existsSync(newSchemaFile)).toBe(true);
+  });
+});

package/src/validate-schema.js

@@ -45,7 +45,7 @@ export const validateSchema = async ({ schema, queries, output }) => {
     const invalidDocuments = validate(graphqlSchema, sources, {
       strictDeprecated: false, // Don't fail on deprecated usage by default
       strictFragments: true,
-      apollo: false,
+      apollo: true, // Enable Apollo Federation directive support
     });
 
     // Transform the results to match expected output format