carto-cli 0.1.0-rc.1

package/dist/logo.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CARTO_LOGO = void 0;
+exports.CARTO_LOGO = `
+   ██████╗ █████╗ ██████╗ ████████╗ ██████╗      ██████╗██╗     ██╗
+  ██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██╔═══██╗    ██╔════╝██║     ██║
+  ██║     ███████║██████╔╝   ██║   ██║   ██║    ██║     ██║     ██║
+  ██║     ██╔══██║██╔══██╗   ██║   ██║   ██║    ██║     ██║     ██║
+  ╚██████╗██║  ██║██║  ██║   ██║   ╚██████╔╝    ╚██████╗███████╗██║
+   ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝    ╚═════╝      ╚═════╝╚══════╝╚═╝
+`;

package/dist/prompt.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForConfirmation = promptForConfirmation;
+const readline = __importStar(require("readline"));
+/**
+ * Prompt the user for confirmation by typing a specific word
+ * @param message The message to display before the prompt
+ * @param expectedInput The exact string the user must type (case-sensitive)
+ * @returns Promise that resolves to true if user entered correct input, false otherwise
+ */
+async function promptForConfirmation(message, expectedInput) {
+    // Check if we're in an interactive terminal
+    if (!process.stdin.isTTY) {
+        // Non-interactive mode - cannot prompt
+        return false;
+    }
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        // Handle Ctrl+C gracefully
+        rl.on('SIGINT', () => {
+            console.log('\n'); // New line after ^C
+            rl.close();
+            resolve(false);
+        });
+        rl.question(message, (answer) => {
+            rl.close();
+            const trimmedAnswer = answer.trim();
+            resolve(trimmedAnswer === expectedInput);
+        });
+    });
+}

package/dist/schedule-parser.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Schedule expression parser for different data warehouse providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScheduleExpression = parseScheduleExpression;
+const DAYS_OF_WEEK_MAP = {
+    'sunday': 0,
+    'sun': 0,
+    'monday': 1,
+    'mon': 1,
+    'tuesday': 2,
+    'tue': 2,
+    'wednesday': 3,
+    'wed': 3,
+    'thursday': 4,
+    'thu': 4,
+    'friday': 5,
+    'fri': 5,
+    'saturday': 6,
+    'sat': 6,
+};
+/**
+ * Parse schedule expression based on provider type
+ */
+function parseScheduleExpression(expression, provider) {
+    const normalizedProvider = provider.toLowerCase();
+    if (normalizedProvider === 'bigquery' || normalizedProvider === 'bq' || normalizedProvider.includes('carto')) {
+        return parseNaturalLanguage(expression);
+    }
+    else if (normalizedProvider === 'snowflake' || normalizedProvider === 'sf' ||
+        normalizedProvider === 'postgres' || normalizedProvider === 'postgresql' ||
+        normalizedProvider === 'redshift' || normalizedProvider === 'rs') {
+        return parseCron(expression);
+    }
+    else if (normalizedProvider === 'databricks' || normalizedProvider === 'databricksrest' || normalizedProvider === 'db') {
+        return parseQuartzCron(expression);
+    }
+    throw new Error(`Unsupported provider: ${provider}`);
+}
+/**
+ * Parse natural language schedule expressions (BigQuery/CARTO DW)
+ */
+function parseNaturalLanguage(expr) {
+    const normalized = expr.toLowerCase().trim();
+    // Pattern: "every day HH:MM"
+    const dailyPattern = /^every\s+day\s+(\d{1,2}):(\d{2})$/;
+    const dailyMatch = normalized.match(dailyPattern);
+    if (dailyMatch) {
+        const hour = parseInt(dailyMatch[1], 10);
+        const minute = parseInt(dailyMatch[2], 10);
+        return {
+            time: `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`,
+            frequency: 4,
+            daysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    // Pattern: "every (monday|tuesday|...) HH:MM"
+    const weeklyPattern = /^every\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tue|wed|thu|fri|sat|sun)\s+(\d{1,2}):(\d{2})$/;
+    const weeklyMatch = normalized.match(weeklyPattern);
+    if (weeklyMatch) {
+        const dayName = weeklyMatch[1];
+        const dayOfWeek = DAYS_OF_WEEK_MAP[dayName];
+        const hour = parseInt(weeklyMatch[2], 10);
+        const minute = parseInt(weeklyMatch[3], 10);
+        return {
+            time: `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`,
+            frequency: 4,
+            daysOfWeek: [dayOfWeek],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    // Pattern: "every N hours" or "every N hour"
+    const hourlyPattern = /^every\s+(\d+)\s+hours?$/;
+    const hourlyMatch = normalized.match(hourlyPattern);
+    if (hourlyMatch) {
+        const interval = parseInt(hourlyMatch[1], 10);
+        return {
+            time: "00:00",
+            frequency: 4,
+            daysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: interval
+        };
+    }
+    // Pattern: "every hour"
+    if (normalized === 'every hour') {
+        return {
+            time: "00:00",
+            frequency: 4,
+            daysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    // Pattern: "N of month HH:MM" or "N,M,O of month HH:MM"
+    const monthlyPattern = /^(\d+(?:,\d+)*)\s+of\s+month\s+(\d{1,2}):(\d{2})$/;
+    const monthlyMatch = normalized.match(monthlyPattern);
+    if (monthlyMatch) {
+        const days = monthlyMatch[1].split(',').map(d => parseInt(d, 10));
+        const hour = parseInt(monthlyMatch[2], 10);
+        const minute = parseInt(monthlyMatch[3], 10);
+        return {
+            time: `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`,
+            frequency: 4,
+            daysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            daysOfMonth: days,
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    // Pattern: "Nth weekday of month HH:MM" (e.g., "1st monday of month 09:00")
+    const ordinalWeekdayPattern = /^(\d+(?:st|nd|rd|th)?)\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tue|wed|thu|fri|sat|sun)\s+of\s+month\s+(\d{1,2}):(\d{2})$/;
+    const ordinalWeekdayMatch = normalized.match(ordinalWeekdayPattern);
+    if (ordinalWeekdayMatch) {
+        const dayName = ordinalWeekdayMatch[2];
+        const dayOfWeek = DAYS_OF_WEEK_MAP[dayName];
+        const hour = parseInt(ordinalWeekdayMatch[3], 10);
+        const minute = parseInt(ordinalWeekdayMatch[4], 10);
+        return {
+            time: `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`,
+            frequency: 4,
+            daysOfWeek: [dayOfWeek],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    // For any other complex BigQuery format, return a default structure
+    // Extract time if present
+    const timeMatch = normalized.match(/(\d{1,2}):(\d{2})/);
+    if (timeMatch) {
+        const hour = parseInt(timeMatch[1], 10);
+        const minute = parseInt(timeMatch[2], 10);
+        return {
+            time: `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`,
+            frequency: 4,
+            daysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            daysOfMonth: [],
+            expression: expr,
+            repeatInterval: 1
+        };
+    }
+    throw new Error(`Invalid BigQuery/CARTO schedule expression: ${expr}. Expected formats: "every day HH:MM", "every monday HH:MM", "every N hours", "N of month HH:MM"`);
+}
+/**
+ * Parse standard cron expression (Snowflake/PostgreSQL/Redshift)
+ * Format: minute hour day-of-month month day-of-week
+ */
+function parseCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length < 5) {
+        throw new Error(`Invalid cron expression: ${expr}. Expected format: "M H D M W"`);
+    }
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    // Parse time
+    const hourNum = parseInt(hour, 10);
+    const minuteNum = parseInt(minute, 10);
+    if (isNaN(hourNum) || isNaN(minuteNum)) {
+        throw new Error(`Invalid time in cron expression: ${expr}`);
+    }
+    const time = `${hourNum.toString().padStart(2, '0')}:${minuteNum.toString().padStart(2, '0')}`;
+    // Parse days of week (0=Sunday, 7=Sunday)
+    let daysOfWeek = [];
+    if (dayOfWeek === '*') {
+        daysOfWeek = [0, 1, 2, 3, 4, 5, 6];
+    }
+    else if (dayOfWeek.includes(',')) {
+        daysOfWeek = dayOfWeek.split(',').map(d => {
+            const num = parseInt(d, 10);
+            return num === 7 ? 0 : num; // Convert 7 to 0 (Sunday)
+        });
+    }
+    else if (dayOfWeek.includes('*/')) {
+        // Every N days - treat as all days
+        daysOfWeek = [0, 1, 2, 3, 4, 5, 6];
+    }
+    else {
+        const num = parseInt(dayOfWeek, 10);
+        daysOfWeek = [num === 7 ? 0 : num];
+    }
+    // Parse days of month
+    let daysOfMonth = [];
+    if (dayOfMonth !== '*' && !dayOfMonth.includes('/')) {
+        if (dayOfMonth.includes(',')) {
+            daysOfMonth = dayOfMonth.split(',').map(d => parseInt(d, 10));
+        }
+        else {
+            daysOfMonth = [parseInt(dayOfMonth, 10)];
+        }
+    }
+    // Detect interval schedules (every N hours)
+    let repeatInterval = 1;
+    if (hour.includes('*/')) {
+        const match = hour.match(/\*\/(\d+)/);
+        if (match) {
+            repeatInterval = parseInt(match[1], 10);
+        }
+    }
+    return {
+        time,
+        frequency: 4,
+        daysOfWeek,
+        daysOfMonth,
+        expression: expr,
+        repeatInterval
+    };
+}
+/**
+ * Parse Quartz cron expression (Databricks)
+ * Format: second minute hour day-of-month month day-of-week [year]
+ */
+function parseQuartzCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length < 6) {
+        throw new Error(`Invalid Quartz cron expression: ${expr}. Expected format: "S M H D M W [Y]"`);
+    }
+    const [second, minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    // Parse time
+    const hourNum = parseInt(hour, 10);
+    const minuteNum = parseInt(minute, 10);
+    if (isNaN(hourNum) || isNaN(minuteNum)) {
+        throw new Error(`Invalid time in Quartz cron expression: ${expr}`);
+    }
+    const time = `${hourNum.toString().padStart(2, '0')}:${minuteNum.toString().padStart(2, '0')}`;
+    // Parse days of week (1=Sunday in Quartz, or MON/TUE/etc)
+    let daysOfWeek = [];
+    if (dayOfWeek === '?' || dayOfWeek === '*') {
+        daysOfWeek = [0, 1, 2, 3, 4, 5, 6];
+    }
+    else if (/^[A-Z]{3}$/.test(dayOfWeek.toUpperCase())) {
+        // Named day (MON, TUE, etc)
+        const dayName = dayOfWeek.toLowerCase();
+        const dayNum = DAYS_OF_WEEK_MAP[dayName];
+        if (dayNum !== undefined) {
+            daysOfWeek = [dayNum];
+        }
+    }
+    else if (dayOfWeek.includes(',')) {
+        daysOfWeek = dayOfWeek.split(',').map(d => {
+            if (/^[A-Z]{3}$/i.test(d)) {
+                return DAYS_OF_WEEK_MAP[d.toLowerCase()];
+            }
+            const num = parseInt(d, 10);
+            return num === 1 ? 0 : num - 1; // Quartz: 1=Sunday, convert to 0=Sunday
+        });
+    }
+    else {
+        const num = parseInt(dayOfWeek, 10);
+        if (!isNaN(num)) {
+            daysOfWeek = [num === 1 ? 0 : num - 1];
+        }
+    }
+    // Parse days of month
+    let daysOfMonth = [];
+    if (dayOfMonth !== '?' && dayOfMonth !== '*' && !dayOfMonth.includes('/')) {
+        if (dayOfMonth.includes(',')) {
+            daysOfMonth = dayOfMonth.split(',').map(d => parseInt(d, 10));
+        }
+        else {
+            daysOfMonth = [parseInt(dayOfMonth, 10)];
+        }
+    }
+    // Detect interval schedules
+    let repeatInterval = 1;
+    if (hour.includes('*/')) {
+        const match = hour.match(/\*\/(\d+)/);
+        if (match) {
+            repeatInterval = parseInt(match[1], 10);
+        }
+    }
+    return {
+        time,
+        frequency: 4,
+        daysOfWeek,
+        daysOfMonth,
+        expression: expr,
+        repeatInterval
+    };
+}

package/jest.config.ts

@@ -0,0 +1,43 @@
+import type { Config } from '@jest/types';
+
+const config: Config.InitialOptions = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/__tests__'],
+  testRegex: '/__tests__/.*\\.(spec|test)\\.ts$',
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'text-summary', 'lcov'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/logo.ts',
+    '!src/index.ts',
+    '!src/commands/**/*.ts',  // Commands tested via integration tests with mocks
+    '!src/prompt.ts'          // Interactive prompts not unit-testable
+  ],
+  coverageThreshold: {
+    global: {
+      // Raised thresholds after comprehensive unit test coverage
+      statements: 75,
+      branches: 70,
+      functions: 70,
+      lines: 75
+    }
+  },
+  setupFilesAfterEnv: ['<rootDir>/__tests__/setup.ts'],
+  testPathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/__tests__/e2e/',
+    '<rootDir>/__tests__/fixtures/',
+    '<rootDir>/__tests__/mocks/'
+  ],
+  transform: {
+    '\\.ts$': 'ts-jest'
+  },
+  clearMocks: true,
+  // Increase timeout for integration tests
+  testTimeout: 10000
+};
+
+export default config;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "carto-cli",
+  "version": "0.1.0-rc.1",
+  "description": "CARTO CLI - Geospatial Cloud Native Platform Admin Tool",
+  "main": "dist/index.js",
+  "bin": {
+    "carto": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "ncc build dist/index.js -o bundle && cp bundle/index.js bundle/carto",
+    "watch": "ncc build src/index.ts -o bundle --watch && mv bundle/index.js bundle/carto",
+    "pkg": "pkg bundle/carto -t node18-macos-x64,node18-linux-x64,node18-win-x64 -o bin/carto",
+    "start": "node dist/index.js",
+    "dev": "npm run build && node dist/index.js",
+    "build:all": "npm run build && npm run bundle && npm run pkg",
+    "test": "jest --config jest.config.ts",
+    "test:watch": "jest --config jest.config.ts --watch",
+    "test:unit": "jest --config jest.config.ts __tests__/unit",
+    "test:integration": "jest --config jest.config.ts __tests__/integration",
+    "test:coverage": "jest --config jest.config.ts --coverage",
+    "bun:dev": "bun run src/index.ts",
+    "bun:bundle": "bun build src/index.ts --outfile bun-bundle/carto.js --target node",
+    "bun:compile": "bun build src/index.ts --compile --outfile bun-bin/carto",
+    "bun:compile:all": "bun build src/index.ts --compile --outfile bun-bin/carto-macos && bun build src/index.ts --compile --target=bun-linux-x64 --outfile bun-bin/carto-linux && bun build src/index.ts --compile --target=bun-windows-x64 --outfile bun-bin/carto-windows.exe"
+  },
+  "keywords": [
+    "carto",
+    "cli",
+    "geospatial",
+    "admin"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.7.0",
+    "@vercel/ncc": "^0.38.4",
+    "jest": "^30.2.0",
+    "memfs": "^4.51.1",
+    "pkg": "^5.8.1",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "overrides": {
+    "node-gyp": "^11.0.0"
+  }
+}