@robylon/react-native-sdk 2.0.21-dev.2 → 2.0.21-staging.0

package/scripts/prevent-direct-branch.js

@@ -0,0 +1,37 @@
+const { execSync } = require("child_process");
+
+// Get command line arguments passed by Git
+// In post-checkout hook, Git passes 3 arguments:
+// 1. Previous HEAD ref
+// 2. New HEAD ref
+// 3. Flag (1 for branch checkout, 0 for file checkout)
+const [prevHead, newHead, checkoutFlag] = process.argv.slice(2);
+
+try {
+  // Get the current branch name
+  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+    .toString()
+    .trim();
+
+  // Only check for branch creation (when prevHead and newHead are different and checkoutFlag is 1)
+  const isBranchCreation = prevHead !== newHead && checkoutFlag === "1";
+
+  // Check if this was a direct branch creation
+  if (
+    isBranchCreation && // Only check actual branch creation
+    !currentBranch.includes("temp-version-update")
+  ) {
+    // If we moved from one branch to a new one, it was likely created directly
+    if (!process.env.BRANCH_CREATION_ALLOWED) {
+      console.error("\n❌ Direct branch creation is not allowed.");
+      console.error("Please use: npm run branch");
+      console.error(
+        "This ensures proper version control and naming conventions."
+      );
+      process.exit(1);
+    }
+  }
+} catch (error) {
+  // If we can't determine, let it pass
+  process.exit(0);
+}

package/scripts/publish-version.js

@@ -0,0 +1,13 @@
+const { execSync } = require("child_process");
+
+// Get current branch name
+const branch = execSync("git rev-parse --abbrev-ref HEAD").toString().trim();
+
+// If we're on a release branch, don't increment version
+if (branch.startsWith("release/v")) {
+  console.log("On release branch - skipping version increment");
+  process.exit(0);
+} else {
+  // For other branches, increment patch version
+  execSync("npm version patch", { stdio: "inherit" });
+}

package/scripts/release.js

@@ -0,0 +1,77 @@
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const release = async () => {
+  try {
+    // 1. Validate current branch is a release branch
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+
+    if (!currentBranch.startsWith("release/v")) {
+      throw new Error(
+        "Release process must be started from a release branch.\n" +
+          `Current branch: ${currentBranch}\n` +
+          "Expected format: release/v{version}"
+      );
+    }
+
+    // 2. Check if version is already published
+    const version = currentBranch.split("/v")[1];
+    const publishedVersions = execSync(
+      "npm view @robylon/web-react-sdk versions --json"
+    ).toString();
+
+    if (publishedVersions.includes(version)) {
+      throw new Error(
+        `Version ${version} is already published to npm.\n` +
+          "Please create a new release branch with a different version."
+      );
+    }
+
+    // 3. Confirm release process
+    console.log("\n📦 Starting release process for version", version);
+    console.log("\nThis will:");
+    console.log("1. Publish to npm");
+    console.log("2. Create git tag");
+    console.log("3. Merge to main");
+
+    const proceed = await new Promise((resolve) =>
+      rl.question("\nProceed with release? (y/N): ", resolve)
+    );
+
+    if (proceed.toLowerCase() !== "y") {
+      throw new Error("Release cancelled by user");
+    }
+
+    // 4. Run publish
+    console.log("\n🚀 Publishing to npm...");
+    execSync("npm run publish:production", { stdio: "inherit" });
+
+    // 5. Merge to main
+    console.log("\n🔄 Merging to main...");
+    execSync("git checkout main");
+    execSync("git pull origin main");
+    execSync(
+      `git merge ${currentBranch} --no-ff -m "chore: release version ${version}"`
+    );
+    execSync("git push origin main");
+
+    console.log("\n✅ Release completed successfully!");
+    console.log(`Version ${version} is now available on npm`);
+    console.log("Changes have been merged to main");
+  } catch (error) {
+    console.error("\n❌ Release failed:");
+    console.error(error.message);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+};
+
+release();

package/scripts/setup-git-hooks.js

@@ -0,0 +1,18 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+// Create .git/hooks directory if it doesn't exist
+const hooksDir = path.join(__dirname, "../.git/hooks");
+if (!fs.existsSync(hooksDir)) {
+  fs.mkdirSync(hooksDir, { recursive: true });
+}
+
+// Copy the validate-branch-name script
+const sourcePath = path.join(__dirname, "validate-branch-name.sh");
+const targetPath = path.join(hooksDir, "commit-msg");
+
+fs.copyFileSync(sourcePath, targetPath);
+fs.chmodSync(targetPath, "755");
+
+console.log("Git hooks installed successfully!");

package/scripts/update-version.js

@@ -0,0 +1,28 @@
+const fs = require("fs");
+const path = require("path");
+
+function updateVersion(env) {
+  const packageJson = require("../package.json");
+  const version = packageJson.version;
+
+  const content = `// This file is auto-generated. Do not modify it manually.
+export const SDK_VERSION = '${version}';\n`;
+
+  const versionFile = path.join(__dirname, `../src/versions/version.${env}.ts`);
+  fs.writeFileSync(versionFile, content);
+
+  // Create/update the main version file that imports the correct version
+  const mainVersionContent = `// This file is auto-generated. Do not modify it manually.
+export { SDK_VERSION } from './versions/version.${env}';\n`;
+
+  fs.writeFileSync(
+    path.join(__dirname, "../src/version.ts"),
+    mainVersionContent
+  );
+
+  console.log(`Updated ${env} SDK_VERSION to ${version}`);
+}
+
+// Get environment from command line argument or default to 'staging'
+const env = process.argv[2] || "staging";
+updateVersion(env);

package/scripts/validate-branch-name.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+echo "DEBUG: Script executed from: $0"
+echo "DEBUG: PWD: $(pwd)"
+
+# Get the full version including staging suffix if present
+FULL_VERSION=$(node -p "require('./package.json').version")
+
+# Check if this is a staging version before any other operations
+if [[ $FULL_VERSION == *"-staging."* ]]; then
+  echo "Staging version detected. Skipping branch name validation."
+  exit 0
+fi
+
+# Get base version without pre-release tags (e.g., 1.1.14 from 1.1.14-staging.0)
+BASE_VERSION=$(echo $FULL_VERSION | cut -d'-' -f1)
+
+# Get the branch name
+BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
+
+# Get latest published version from npm
+LATEST_VERSION=$(npm view @robylon/web-react-sdk version 2>/dev/null || echo "0.0.0")
+
+# Regular expression for valid branch names
+FEATURE_PATTERN="^feature/v[0-9]+\.[0-9]+\.[0-9]+/[a-z0-9-]+$"
+RELEASE_PATTERN="^release/v${BASE_VERSION}$"
+HOTFIX_PATTERN="^hotfix/v[0-9]+\.[0-9]+\.[0-9]+(-patch\.[0-9]+)?$"
+
+echo "Validating branch: $BRANCH_NAME"
+echo "Current version: $BASE_VERSION"
+echo "Latest published version: $LATEST_VERSION"
+
+# For release branches, ensure version matches branch exactly
+if [[ $BRANCH_NAME =~ ^release/v ]]; then
+    # Extract version from branch name
+    BRANCH_VERSION=$(echo $BRANCH_NAME | sed 's/release\/v//')
+    
+    # Check if branch version matches package version
+    if [[ "$BRANCH_VERSION" != "$BASE_VERSION" ]]; then
+        echo "Error: Release branch version ($BRANCH_VERSION) must match package.json version ($BASE_VERSION)"
+        exit 1
+    fi
+    
+    # Check if trying to publish a version behind latest
+    if [[ $(node -p "require('semver').lt('$BASE_VERSION', '$LATEST_VERSION')") == "true" ]]; then
+        echo "Error: Cannot publish version $BASE_VERSION as it is behind the latest published version $LATEST_VERSION"
+        exit 1
+    fi
+    
+    echo "✅ Valid release branch name and version"
+    exit 0
+fi
+
+# Validate other branch types
+if [[ $BRANCH_NAME =~ $FEATURE_PATTERN ]] || [[ $BRANCH_NAME =~ $HOTFIX_PATTERN ]]; then
+    echo "✅ Valid branch name"
+    exit 0
+else
+    echo "Error: Invalid branch name format."
+    echo "Branch names must follow these formats:"
+    echo "- For feature branches: feature/v{version}/{feature-name}"
+    echo "- For release branches: release/v{version}"
+    echo "- For hotfix branches: hotfix/v{version}-patch.{number}"
+    exit 1
+fi

package/scripts/validate-publish.js

@@ -0,0 +1,48 @@
+const { execSync } = require("child_process");
+
+const validatePublish = () => {
+  try {
+    // Get current branch
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")
+      .toString()
+      .trim();
+    console.log("Validating branch:", currentBranch);
+
+    if (!currentBranch.startsWith("release/v")) {
+      throw new Error("Publishing is only allowed from release branches");
+    }
+
+    // Get version from branch name
+    const branchVersion = currentBranch.split("/v")[1];
+
+    // Get version from package.json
+    const packageVersion = require("../package.json").version;
+    console.log("Current version:", packageVersion);
+
+    // Get latest published version
+    const latestVersion = execSync("npm view @robylon/react-native-sdk version")
+      .toString()
+      .trim();
+    console.log("Latest published version:", latestVersion);
+
+    // Ensure branch version matches package.json version
+    if (branchVersion !== packageVersion) {
+      throw new Error(
+        `Release branch version (${branchVersion}) must match package.json version (${packageVersion})`
+      );
+    }
+
+    // Validate version is greater than latest published
+    const semver = require("semver");
+    if (!semver.gt(packageVersion, latestVersion)) {
+      throw new Error(
+        `New version (${packageVersion}) must be greater than latest published version (${latestVersion})`
+      );
+    }
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+};
+
+validatePublish();

package/src/ChatbotWebview.tsx

@@ -0,0 +1,44 @@
+// File: src/ChatbotWebview.tsx
+import React, { useEffect, useState } from "react";
+import { View } from "react-native";
+import { WebView } from "react-native-webview";
+import { BASE_CHATBOT_URL } from "./constants";
+import LoadingIndicator from "./LoadingIndicator";
+
+interface ChatbotWebviewProps {
+  chatbotId: string;
+  additionalParams?: Record<string, string>;
+}
+
+const constructUrl = (
+  chatbotId: string,
+  additionalParams: Record<string, string> = {}
+): string => {
+  const params = new URLSearchParams({ id: chatbotId, ...additionalParams });
+  return `${BASE_CHATBOT_URL}?${params.toString()}`;
+};
+
+export const ChatbotWebview: React.FC<ChatbotWebviewProps> = ({
+  chatbotId,
+  additionalParams,
+}) => {
+  const [url, setUrl] = useState<string>("");
+
+  useEffect(() => {
+    setUrl(constructUrl(chatbotId, additionalParams));
+  }, [chatbotId, additionalParams]);
+
+  return (
+    <View style={{ flex: 1 }}>
+      {url ? (
+        <WebView
+          source={{ uri: url }}
+          startInLoadingState={true}
+          renderLoading={() => <LoadingIndicator />}
+        />
+      ) : (
+        <LoadingIndicator />
+      )}
+    </View>
+  );
+};