@medipass/checkout-sdk 3.1.0 → 3.3.0-beta.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medipass/checkout-sdk",
-  "version": "3.1.0",
+  "version": "3.3.0-beta.7",
   "description": "Medipass Checkout SDK",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -11,11 +11,12 @@
     "develop": "nodemon -w src -x 'yarn build'",
     "lint": "eslint \"**/*.{ts,tsx}\"",
     "lint:fix": "eslint \"**/*.{ts,tsx}\" --fix",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "yarn build",
+    "release": "node scripts/release.mjs"
   },
   "dependencies": {
-    "@medipass/utils": "11.80.7",
-    "@medipass/web-sdk": "11.64.8"
+    "@medipass/utils": "11.88.0",
+    "@medipass/web-sdk": "12.5.1"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "25.0.3",

package/scripts/release.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+/* eslint-disable no-undef */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync } from 'fs';
+import * as readline from 'readline';
+
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const question = prompt => new Promise(resolve => rl.question(prompt, resolve));
+
+const exec = (cmd, options = {}) => {
+  if (dryRun) {
+    console.log(`\n[DRY RUN] Would execute: ${cmd}`);
+    return;
+  }
+  console.log(`\n> ${cmd}`);
+  return execSync(cmd, { stdio: 'inherit', ...options });
+};
+
+const execOutput = cmd => execSync(cmd, { encoding: 'utf-8' }).trim();
+
+const getCurrentBranch = () => execOutput('git rev-parse --abbrev-ref HEAD');
+
+const getPackageJson = () => {
+  const content = readFileSync('package.json', 'utf-8');
+  return JSON.parse(content);
+};
+
+const writePackageJson = pkg => {
+  writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+};
+
+const parseVersion = version => {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([a-z]+)\.(\d+))?$/);
+  if (!match) throw new Error(`Invalid version format: ${version}`);
+  return {
+    major: parseInt(match[1]),
+    minor: parseInt(match[2]),
+    patch: parseInt(match[3]),
+    preId: match[4] || null,
+    preNum: match[5] ? parseInt(match[5]) : null,
+  };
+};
+
+const formatVersion = ({ major, minor, patch, preId, preNum }) => {
+  const base = `${major}.${minor}.${patch}`;
+  return preId ? `${base}-${preId}.${preNum}` : base;
+};
+
+const bumpVersion = (currentVersion, releaseType, preId = 'beta', preTarget = 'patch') => {
+  const v = parseVersion(currentVersion);
+
+  switch (releaseType) {
+    case 'major':
+      // If current is a pre-release for a major bump, graduate it
+      if (v.preId && v.minor === 0 && v.patch === 0) {
+        return formatVersion({ major: v.major, minor: 0, patch: 0, preId: null, preNum: null });
+      }
+      return formatVersion({ major: v.major + 1, minor: 0, patch: 0, preId: null, preNum: null });
+    case 'minor':
+      // If current is a pre-release for a minor bump, graduate it
+      if (v.preId && v.patch === 0) {
+        return formatVersion({ major: v.major, minor: v.minor, patch: 0, preId: null, preNum: null });
+      }
+      return formatVersion({ major: v.major, minor: v.minor + 1, patch: 0, preId: null, preNum: null });
+    case 'patch':
+      // If current is a pre-release, graduate it to stable (strip the pre-release suffix)
+      if (v.preId) {
+        return formatVersion({ major: v.major, minor: v.minor, patch: v.patch, preId: null, preNum: null });
+      }
+      return formatVersion({ major: v.major, minor: v.minor, patch: v.patch + 1, preId: null, preNum: null });
+    case 'pre':
+      // If already a pre-release, just bump the pre-release number
+      if (v.preId) {
+        return formatVersion({ ...v, preNum: v.preNum + 1 });
+      }
+      // Otherwise, bump based on preTarget and add pre-release suffix
+      switch (preTarget) {
+        case 'major':
+          return formatVersion({ major: v.major + 1, minor: 0, patch: 0, preId, preNum: 0 });
+        case 'minor':
+          return formatVersion({ major: v.major, minor: v.minor + 1, patch: 0, preId, preNum: 0 });
+        case 'patch':
+        default:
+          return formatVersion({ major: v.major, minor: v.minor, patch: v.patch + 1, preId, preNum: 0 });
+      }
+    default:
+      throw new Error(`Unknown release type: ${releaseType}`);
+  }
+};
+
+const hasUncommittedChanges = () => {
+  try {
+    const status = execOutput('git status --porcelain');
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+};
+
+const checkNpmPublishAccess = () => {
+  try {
+    execSync(`npm publish --dry-run --ignore-scripts 2>&1`, { encoding: 'utf-8' });
+    return { ok: true };
+  } catch (err) {
+    const output = err.stdout || err.stderr || err.message || '';
+    if (output.includes('ENEEDAUTH') || output.includes('need auth')) {
+      return { ok: false, reason: 'not-authenticated' };
+    }
+    if (output.includes('403') || output.includes('not authorized')) {
+      return { ok: false, reason: 'no-access' };
+    }
+    // Other errors (like "already exists") mean auth is fine
+    if (output.includes('already exists') || output.includes('EPUBLISHCONFLICT')) {
+      return { ok: true };
+    }
+    return { ok: false, reason: 'unknown', message: output };
+  }
+};
+
+const main = async () => {
+  console.log('\n📦 Release CLI for @medipass/checkout-sdk\n');
+
+  if (dryRun) {
+    console.log('🧪 DRY RUN MODE - No changes will be made\n');
+  }
+
+  const currentBranch = getCurrentBranch();
+  const pkg = getPackageJson();
+  const currentVersion = pkg.version;
+
+  console.log(`Current branch: ${currentBranch}`);
+  console.log(`Current version: ${currentVersion}\n`);
+
+  if (hasUncommittedChanges()) {
+    console.error('Error: You have uncommitted changes. Please commit or stash them first.');
+    process.exit(1);
+  }
+
+  console.log('Release types:');
+  console.log('  1. pre   - Pre-release (e.g., 3.2.1-beta.0) - feature branch only');
+  console.log('  2. patch - Patch release (e.g., 3.2.1) - master branch only');
+  console.log('  3. minor - Minor release (e.g., 3.3.0) - master branch only');
+  console.log('  4. major - Major release (e.g., 4.0.0) - master branch only');
+  console.log('');
+
+  const typeChoice = await question('Select release type (1-4): ');
+  const releaseTypes = { 1: 'pre', 2: 'patch', 3: 'minor', 4: 'major' };
+  const releaseType = releaseTypes[typeChoice];
+
+  if (!releaseType) {
+    console.error('Invalid selection.');
+    process.exit(1);
+  }
+
+  if (releaseType === 'pre') {
+    if (currentBranch === 'master') {
+      console.error('\nError: Pre-releases must be done on a feature branch, not master.');
+      process.exit(1);
+    }
+  } else {
+    if (currentBranch !== 'master') {
+      console.error(`\nError: ${releaseType} releases must be done on the master branch.`);
+      console.error(`Current branch: ${currentBranch}`);
+      console.error('Please checkout master and merge your changes first.');
+      process.exit(1);
+    }
+  }
+
+  let preId = 'beta';
+  let preTarget = 'patch';
+  if (releaseType === 'pre') {
+    const parsed = parseVersion(currentVersion);
+
+    // Only ask for target if not already a pre-release
+    if (!parsed.preId) {
+      console.log('\nPre-release target version:');
+      console.log('  1. patch (e.g., 3.2.0 -> 3.2.1-beta.0)');
+      console.log('  2. minor (e.g., 3.2.0 -> 3.3.0-beta.0)');
+      console.log('  3. major (e.g., 3.2.0 -> 4.0.0-beta.0)');
+      const targetChoice = await question('Select target (1-3, default: 1): ');
+      const targets = { 1: 'patch', 2: 'minor', 3: 'major' };
+      preTarget = targets[targetChoice] || 'patch';
+    }
+
+    const customPreId = await question('Pre-release identifier (default: beta): ');
+    if (customPreId.trim()) {
+      preId = customPreId.trim().toLowerCase();
+    }
+  }
+
+  const newVersion = bumpVersion(currentVersion, releaseType, preId, preTarget);
+
+  console.log(`\nVersion bump: ${currentVersion} -> ${newVersion}`);
+  const confirm = await question('Proceed? (y/n): ');
+
+  if (confirm.toLowerCase() !== 'y') {
+    console.log('Aborted.');
+    process.exit(0);
+  }
+
+  console.log('\n--- Building (pre-publish check) ---');
+  exec('yarn build');
+
+  console.log('\n--- Checking NPM publish access ---');
+  if (!dryRun) {
+    const access = checkNpmPublishAccess();
+    if (!access.ok) {
+      if (access.reason === 'not-authenticated') {
+        console.error('Error: You are not logged in to NPM.');
+        console.error('Please run: npm login');
+      } else if (access.reason === 'no-access') {
+        console.error(`Error: You don't have publish access to ${pkg.name}.`);
+        console.error('Please contact the package owner to grant you access.');
+      } else {
+        console.error('Error: NPM publish check failed.');
+        if (access.message) console.error(access.message);
+      }
+      process.exit(1);
+    }
+    console.log('NPM publish access: OK');
+  } else {
+    console.log('[DRY RUN] Skipping NPM publish access check');
+  }
+
+  console.log('\n--- Updating version ---');
+  if (dryRun) {
+    console.log(`[DRY RUN] Would update package.json to version ${newVersion}`);
+  } else {
+    pkg.version = newVersion;
+    writePackageJson(pkg);
+    console.log(`Updated package.json to version ${newVersion}`);
+  }
+
+  console.log('\n--- Rebuilding with new version ---');
+  exec('yarn build');
+
+  console.log('\n--- Committing version bump ---');
+  exec('git add package.json');
+  exec(`git commit -m "${newVersion}"`);
+
+  console.log('\n--- Creating git tag ---');
+  const tagName = `v${newVersion}`;
+  exec(`git tag ${tagName}`);
+  console.log(`Created tag: ${tagName}`);
+
+  console.log('\n--- Publishing to NPM ---');
+  const otp = await question('Enter OTP code (or press Enter if 2FA not enabled): ');
+  const otpFlag = otp.trim() ? ` --otp=${otp.trim()}` : '';
+  
+  if (releaseType === 'pre') {
+    exec(`npm publish --tag next --ignore-scripts${otpFlag}`);
+  } else {
+    exec(`npm publish --ignore-scripts${otpFlag}`);
+  }
+
+  const pushConfirm = await question('\nPush commit and tag to remote? (y/n): ');
+  if (pushConfirm.toLowerCase() === 'y') {
+    exec('git push');
+    exec(`git push origin ${tagName}`);
+    console.log('\nPushed to remote.');
+  }
+
+  console.log(`\n✅ Successfully released ${newVersion}`);
+  console.log(`   Tag: ${tagName}`);
+  if (releaseType === 'pre') {
+    console.log('   NPM tag: next');
+    console.log(`   Install with: npm install @medipass/checkout-sdk@next`);
+  }
+
+  rl.close();
+};
+
+main().catch(err => {
+  console.error('\nError:', err.message);
+  rl.close();
+  process.exit(1);
+});

package/src/constants.ts

@@ -18,6 +18,7 @@ export const EVENTS = {
   SUCCESS: 'success',
   fAILURE: 'failure',
   CANCEL: 'cancel',
+  EXPIRED: 'expired',
 } as const;
 
 export const ERROR_MESSAGES = {

package/src/index.ts

@@ -19,12 +19,14 @@ interface CheckoutSdk {
   onSuccess: ((args: { transactionId: string }) => void) | null;
   onFailure: ((args: { transactionId: string }) => void) | null;
   onCancel: ((args: { transactionId: string }) => void) | null;
+  onExpired: ((args: { transactionId: string }) => void) | null;
   onClose: (() => void) | null;
   init: (args: {
     env: typeof ENVS[keyof typeof ENVS];
     onSuccess: (args: { transactionId: string }) => void;
     onFailure: (args: { transactionId: string }) => void;
     onCancel: (args: { transactionId: string }) => void;
+    onExpired: (args: { transactionId: string }) => void;
     onClose: () => void;
   }) => void;
   createCheckout: (args: { paymentRequestUrl: string }) => void;
@@ -39,15 +41,17 @@ const checkoutSDK: CheckoutSdk = {
   onSuccess: null,
   onFailure: null,
   onCancel: null,
+  onExpired: null,
   onClose: null,
 
-  init({ env, onSuccess, onFailure, onCancel, onClose }) {
+  init({ env, onSuccess, onFailure, onCancel, onExpired, onClose }) {
     if (!env) return;
 
     this.env = env;
     this.onSuccess = onSuccess;
     this.onFailure = onFailure;
     this.onCancel = onCancel;
+    this.onExpired = onExpired;
     this.onClose = onClose;
 
     // Open a blank window
@@ -102,6 +106,7 @@ const checkoutSDK: CheckoutSdk = {
     const onSuccess = this.onSuccess;
     const onFailure = this.onFailure;
     const onCancel = this.onCancel;
+    const onExpired = this.onExpired;
     const onClose = this.onClose;
 
     ////////////////////////////////////////////////////////////
@@ -186,6 +191,17 @@ const checkoutSDK: CheckoutSdk = {
           }, 1500);
           return transactionId;
         }
+
+        if (event === EVENTS.EXPIRED) {
+          // Give 1.5 seconds for the user to see the expired page before auto-closing the pop-up.
+          setTimeout(() => {
+            onExpired && onExpired({ transactionId });
+            if (_windowReferenceObject) {
+              _windowReferenceObject.close();
+            }
+          }, 1500);
+          return transactionId;
+        }
       };
 
       return _windowReferenceObject;