@regressionproof/snapshotter 0.3.6 → 0.3.8

package/build/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,35 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.RegressionproofSnapshotter {
+    interface ExecCommandFailed {
+        /** . The command that was attempted */
+        'command': string;
+        'stdout'?: string | undefined | null;
+        'stderr'?: string | undefined | null;
+    }
+    interface ExecCommandFailedSchema extends SpruceSchema.Schema {
+        id: 'execCommandFailed';
+        namespace: 'RegressionproofSnapshotter';
+        name: 'Exec command failed';
+        fields: {
+            /** . The command that was attempted */
+            'command': {
+                type: 'text';
+                isRequired: true;
+                hint: 'The command that was attempted';
+                options: undefined;
+            };
+            /** . */
+            'stdout': {
+                type: 'text';
+                options: undefined;
+            };
+            /** . */
+            'stderr': {
+                type: 'text';
+                options: undefined;
+            };
+        };
+    }
+    type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;
+}

package/build/.spruce/errors/errors.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/.spruce/errors/options.types.d.ts

@@ -0,0 +1,7 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface ExecCommandFailedErrorOptions extends SpruceErrors.RegressionproofSnapshotter.ExecCommandFailed, ISpruceErrorOptions {
+    code: 'EXEC_COMMAND_FAILED';
+}
+type ErrorOptions = ExecCommandFailedErrorOptions;
+export default ErrorOptions;

package/build/.spruce/errors/options.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/.spruce/errors/regressionproofSnapshotter/execCommandFailed.schema.d.ts

@@ -0,0 +1,3 @@
+import { SpruceErrors } from '../errors.types';
+declare const execCommandFailedSchema: SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema;
+export default execCommandFailedSchema;

package/build/.spruce/errors/regressionproofSnapshotter/execCommandFailed.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const execCommandFailedSchema = {
+    id: 'execCommandFailed',
+    namespace: 'RegressionproofSnapshotter',
+    name: 'Exec command failed',
+    fields: {
+        /** . The command that was attempted */
+        'command': {
+            type: 'text',
+            isRequired: true,
+            hint: 'The command that was attempted',
+            options: undefined
+        },
+        /** . */
+        'stdout': {
+            type: 'text',
+            options: undefined
+        },
+        /** . */
+        'stderr': {
+            type: 'text',
+            options: undefined
+        },
+    }
+};
+schema_1.SchemaRegistry.getInstance().trackSchema(execCommandFailedSchema);
+exports.default = execCommandFailedSchema;

package/build/.spruce/schemas/fields/fieldClassMap.d.ts

@@ -0,0 +1,2 @@
+import { fieldClassMap } from '@sprucelabs/schema';
+export default fieldClassMap;

package/build/.spruce/schemas/fields/fieldClassMap.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = schema_1.fieldClassMap;

package/{src/.spruce/schemas/fields/fields.types.ts → build/.spruce/schemas/fields/fields.types.d.ts}

@@ -1 +1 @@
-export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema'
+export { FieldDefinitions, FieldDefinitionMap, FieldValueTypeGeneratorMap, FieldMap } from '@sprucelabs/schema';

package/build/.spruce/schemas/fields/fields.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/errors/SpruceError.d.ts

@@ -0,0 +1,6 @@
+import BaseSpruceError from '@sprucelabs/error';
+import ErrorOptions from './../.spruce/errors/options.types';
+export default class SpruceError extends BaseSpruceError<ErrorOptions> {
+    /** an easy to understand version of the errors */
+    friendlyMessage(): string;
+}

package/build/errors/SpruceError.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const error_1 = __importDefault(require("@sprucelabs/error"));
+class SpruceError extends error_1.default {
+    /** an easy to understand version of the errors */
+    friendlyMessage() {
+        const { options } = this;
+        let message;
+        switch (options?.code) {
+            case 'EXEC_COMMAND_FAILED':
+                message = `The command "${options.command}" failed to execute.
+                
+Stdout:
+${options.stdout ?? '<no stdout>'}
+
+Stderr:
+${options.stderr ?? '<no stderr>'}`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}
+exports.default = SpruceError;

package/build/errors/execCommandFailed.builder.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        command: {
+            type: "text";
+            isRequired: true;
+            hint: string;
+        };
+        stdout: {
+            type: "text";
+        };
+        stderr: {
+            type: "text";
+        };
+    };
+};
+export default _default;

package/build/errors/execCommandFailed.builder.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+exports.default = (0, schema_1.buildErrorSchema)({
+    id: 'execCommandFailed',
+    name: 'Exec command failed',
+    fields: {
+        command: {
+            type: 'text',
+            isRequired: true,
+            hint: 'The command that was attempted',
+        },
+        stdout: {
+            type: 'text',
+        },
+        stderr: {
+            type: 'text',
+        },
+    },
+});

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -0,0 +1,35 @@
+import { default as SchemaEntity } from '@sprucelabs/schema';
+import * as SpruceSchema from '@sprucelabs/schema';
+export declare namespace SpruceErrors.RegressionproofSnapshotter {
+    interface ExecCommandFailed {
+        /** . The command that was attempted */
+        'command': string;
+        'stdout'?: string | undefined | null;
+        'stderr'?: string | undefined | null;
+    }
+    interface ExecCommandFailedSchema extends SpruceSchema.Schema {
+        id: 'execCommandFailed';
+        namespace: 'RegressionproofSnapshotter';
+        name: 'Exec command failed';
+        fields: {
+            /** . The command that was attempted */
+            'command': {
+                type: 'text';
+                isRequired: true;
+                hint: 'The command that was attempted';
+                options: undefined;
+            };
+            /** . */
+            'stdout': {
+                type: 'text';
+                options: undefined;
+            };
+            /** . */
+            'stderr': {
+                type: 'text';
+                options: undefined;
+            };
+        };
+    }
+    type ExecCommandFailedEntity = SchemaEntity<SpruceErrors.RegressionproofSnapshotter.ExecCommandFailedSchema>;
+}

package/build/esm/.spruce/errors/errors.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/.spruce/errors/options.types.d.ts

@@ -0,0 +1,7 @@
+import { SpruceErrors } from "./errors.types";
+import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+export interface ExecCommandFailedErrorOptions extends SpruceErrors.RegressionproofSnapshotter.ExecCommandFailed, ISpruceErrorOptions {
+    code: 'EXEC_COMMAND_FAILED';
+}
+type ErrorOptions = ExecCommandFailedErrorOptions;
+export default ErrorOptions;

package/build/esm/.spruce/errors/options.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/errors/SpruceError.d.ts

@@ -0,0 +1,6 @@
+import BaseSpruceError from '@sprucelabs/error';
+import ErrorOptions from './../.spruce/errors/options.types';
+export default class SpruceError extends BaseSpruceError<ErrorOptions> {
+    /** an easy to understand version of the errors */
+    friendlyMessage(): string;
+}

package/build/esm/errors/SpruceError.js

@@ -0,0 +1,26 @@
+import BaseSpruceError from '@sprucelabs/error';
+export default class SpruceError extends BaseSpruceError {
+    /** an easy to understand version of the errors */
+    friendlyMessage() {
+        var _a, _b;
+        const { options } = this;
+        let message;
+        switch (options === null || options === void 0 ? void 0 : options.code) {
+            case 'EXEC_COMMAND_FAILED':
+                message = `The command "${options.command}" failed to execute.
+                
+Stdout:
+${(_a = options.stdout) !== null && _a !== void 0 ? _a : '<no stdout>'}
+
+Stderr:
+${(_b = options.stderr) !== null && _b !== void 0 ? _b : '<no stderr>'}`;
+                break;
+            default:
+                message = super.friendlyMessage();
+        }
+        const fullMessage = options.friendlyMessage
+            ? options.friendlyMessage
+            : message;
+        return fullMessage;
+    }
+}

package/build/esm/errors/execCommandFailed.builder.d.ts

@@ -0,0 +1,18 @@
+declare const _default: {
+    id: string;
+    name: string;
+    fields: {
+        command: {
+            type: "text";
+            isRequired: true;
+            hint: string;
+        };
+        stdout: {
+            type: "text";
+        };
+        stderr: {
+            type: "text";
+        };
+    };
+};
+export default _default;

package/{src/errors/execCommandFailed.builder.ts → build/esm/errors/execCommandFailed.builder.js}

@@ -1,5 +1,4 @@
-import { buildErrorSchema } from '@sprucelabs/schema'
-
+import { buildErrorSchema } from '@sprucelabs/schema';
 export default buildErrorSchema({
     id: 'execCommandFailed',
     name: 'Exec command failed',
@@ -16,4 +15,4 @@ export default buildErrorSchema({
             type: 'text',
         },
     },
-})
+});

package/build/esm/git.d.ts

@@ -0,0 +1,4 @@
+import { Log } from '@sprucelabs/spruce-skill-utils';
+import { RemoteOptions } from './snapshotter.types.js';
+export declare function gitCommit(mirrorPath: string, log?: Log): Promise<boolean>;
+export declare function gitPush(mirrorPath: string, remote: RemoteOptions, log?: Log): Promise<void>;

package/build/esm/git.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+import SpruceError from './errors/SpruceError.js.js';
+const execAsync = promisify(exec);
+export function gitCommit(mirrorPath, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const gitDir = path.join(mirrorPath, '.git');
+        if (!existsSync(gitDir)) {
+            yield execOrThrow(`git -C "${mirrorPath}" init`, log);
+        }
+        yield execOrThrow(`git -C "${mirrorPath}" add -A`, log);
+        const { stdout } = yield execOrThrow(`git -C "${mirrorPath}" status --porcelain`);
+        if (!stdout.trim()) {
+            log === null || log === void 0 ? void 0 : log.info('No changes detected for commit', mirrorPath);
+            return false;
+        }
+        const message = `Snapshot ${new Date().toISOString()}`;
+        yield execOrThrow(`git -C "${mirrorPath}" commit -m "${message}"`, log);
+        return true;
+    });
+}
+export function gitPush(mirrorPath, remote, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const authedUrl = remote.url.replace('://', `://${remote.token}@`);
+        try {
+            yield execOrThrow(`git -C "${mirrorPath}" remote get-url origin`, log);
+            yield execOrThrow(`git -C "${mirrorPath}" remote set-url origin "${authedUrl}"`);
+        }
+        catch (_a) {
+            yield execOrThrow(`git -C "${mirrorPath}" remote add origin "${authedUrl}"`);
+        }
+        yield execOrThrow(`git -C "${mirrorPath}" push -u origin HEAD`, log);
+    });
+}
+function execOrThrow(command, log) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            return yield execAsync(command);
+        }
+        catch (err) {
+            const error = err;
+            const stdout = (_a = error.stdout) !== null && _a !== void 0 ? _a : '';
+            const stderr = (_b = error.stderr) !== null && _b !== void 0 ? _b : '';
+            log === null || log === void 0 ? void 0 : log.error('Command failed', command, stderr);
+            throw new SpruceError({
+                code: 'EXEC_COMMAND_FAILED',
+                command,
+                stdout,
+                stderr,
+            });
+        }
+    });
+}

package/build/esm/index.d.ts

@@ -0,0 +1,2 @@
+export { snapshot } from './snapshot.js';
+export * from './snapshotter.types.js';

package/build/esm/index.js

@@ -0,0 +1,2 @@
+export { snapshot } from './snapshot.js.js';
+export * from './snapshotter.types.js.js';

package/build/esm/scripts/testManual.d.ts

@@ -0,0 +1 @@
+export {};

package/build/esm/scripts/testManual.js

@@ -0,0 +1,60 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { snapshot } from '../index.js';
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sourcePath = process.env.SOURCE_PATH;
+        const mirrorPath = process.env.MIRROR_PATH;
+        const remoteUrl = process.env.REMOTE_URL;
+        const remoteToken = process.env.REMOTE_TOKEN;
+        if (!sourcePath || !mirrorPath || !remoteUrl || !remoteToken) {
+            console.error('Missing required env vars. See .env.example');
+            process.exit(1);
+        }
+        console.log('Running snapshot...');
+        console.log('  Source:', sourcePath);
+        console.log('  Mirror:', mirrorPath);
+        console.log('  Remote:', remoteUrl);
+        const result = yield snapshot({
+            sourcePath,
+            mirrorPath,
+            testResults: {
+                timestamp: new Date().toISOString(),
+                summary: {
+                    totalSuites: 1,
+                    passedSuites: 1,
+                    failedSuites: 0,
+                    totalTests: 2,
+                    passedTests: 2,
+                    failedTests: 0,
+                },
+                suites: [
+                    {
+                        path: 'src/__tests__/Example.test.ts',
+                        passed: true,
+                        tests: [
+                            { name: 'should work', passed: true },
+                            { name: 'should also work', passed: true },
+                        ],
+                    },
+                ],
+            },
+            remote: {
+                url: remoteUrl,
+                token: remoteToken,
+            },
+        });
+        console.log('Snapshot created:', result);
+    });
+}
+main().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});

package/build/esm/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { SnapshotOptions } from './snapshotter.types.js';
+export declare function snapshot(options: SnapshotOptions): Promise<boolean>;

package/build/esm/snapshot.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+import { buildLog } from '@sprucelabs/spruce-skill-utils';
+import { gitCommit, gitPush } from './git.js.js';
+import { syncFiles } from './sync.js.js';
+class Snapshotter {
+    constructor() {
+        this.log = buildLog('Snapshotter');
+    }
+    snapshot(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sourcePath = (_a = options.sourcePath) !== null && _a !== void 0 ? _a : process.cwd();
+            const { mirrorPath, testResults, remote } = options;
+            this.log.info('Starting snapshot', sourcePath, mirrorPath);
+            try {
+                yield syncFiles(sourcePath, mirrorPath);
+                this.log.info('Files synced', mirrorPath);
+                const snapshotterDir = path.join(mirrorPath, '.snapshotter');
+                mkdirSync(snapshotterDir, { recursive: true });
+                writeFileSync(path.join(snapshotterDir, 'testResults.json'), JSON.stringify(testResults, null, 2));
+                this.log.info('Test results saved', snapshotterDir);
+                const committed = yield gitCommit(mirrorPath, this.log);
+                if (!committed) {
+                    this.log.info('No changes to commit', mirrorPath);
+                    return false;
+                }
+                this.log.info('Commit created, pushing', remote.url);
+                yield gitPush(mirrorPath, remote, this.log);
+                this.log.info('Push completed', remote.url);
+                return true;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.log.error('Snapshot failed', message);
+                throw err;
+            }
+        });
+    }
+}
+export function snapshot(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Snapshotter().snapshot(options);
+    });
+}

package/{src/snapshotter.types.ts → build/esm/snapshotter.types.d.ts}

@@ -1,59 +1,54 @@
 export interface TestResult {
     /** Name of the individual test */
-    name: string
+    name: string;
     /** Whether this test passed */
-    passed: boolean
+    passed: boolean;
     /** Full error message + callstack (only present if failed) */
-    error?: string
+    error?: string;
 }
-
 export interface SuiteResult {
     /** Path to test file, relative to project root */
-    path: string
+    path: string;
     /** Whether all tests in suite passed */
-    passed: boolean
+    passed: boolean;
     /** Array of test results */
-    tests: TestResult[]
+    tests: TestResult[];
 }
-
 export interface TestResultsSummary {
     /** Total number of test suites (files) */
-    totalSuites: number
+    totalSuites: number;
     /** Number of suites with all tests passing */
-    passedSuites: number
+    passedSuites: number;
     /** Number of suites with at least one failure */
-    failedSuites: number
+    failedSuites: number;
     /** Total number of individual tests */
-    totalTests: number
+    totalTests: number;
     /** Number of passing tests */
-    passedTests: number
+    passedTests: number;
     /** Number of failing tests */
-    failedTests: number
+    failedTests: number;
 }
-
 export interface TestResults {
     /** ISO 8601 timestamp of when test run completed */
-    timestamp: string
+    timestamp: string;
     /** Summary counts */
-    summary: TestResultsSummary
+    summary: TestResultsSummary;
     /** Array of suite results */
-    suites: SuiteResult[]
+    suites: SuiteResult[];
 }
-
 export interface RemoteOptions {
     /** Gitea repo URL to push to */
-    url: string
+    url: string;
     /** Gitea access token for authentication */
-    token: string
+    token: string;
 }
-
 export interface SnapshotOptions {
     /** Source project path to sync from. Defaults to process.cwd() */
-    sourcePath?: string
+    sourcePath?: string;
     /** Mirror directory path where the isolated git repo lives */
-    mirrorPath: string
+    mirrorPath: string;
     /** Test results from the completed test run */
-    testResults: TestResults
+    testResults: TestResults;
     /** Remote Gitea repo to push to */
-    remote: RemoteOptions
+    remote: RemoteOptions;
 }

package/build/esm/snapshotter.types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/sync.d.ts

@@ -0,0 +1 @@
+export declare function syncFiles(sourcePath: string, mirrorPath: string): Promise<void>;

package/build/esm/sync.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const DEFAULT_EXCLUDES = [
+    'node_modules',
+    'build',
+    '*.env*',
+    '*.pem',
+    '*.key',
+    '*.p12',
+    '*.pfx',
+    '*credentials*',
+    '*secret*',
+    '*.local',
+];
+export function syncFiles(sourcePath, mirrorPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hasGitIgnore = existsSync(path.join(sourcePath, '.gitignore'));
+        const excludes = DEFAULT_EXCLUDES.map((e) => `--exclude='${e}'`).join(' ');
+        if (hasGitIgnore) {
+            const cmd = `cd "${sourcePath}" && git ls-files --cached --others --exclude-standard -z | rsync -av --files-from=- --from0 ${excludes} . "${mirrorPath}/"`;
+            yield execAsync(cmd);
+        }
+        else {
+            const cmd = `rsync -av --delete ${excludes} "${sourcePath}/" "${mirrorPath}/"`;
+            yield execAsync(cmd);
+        }
+    });
+}

package/build/git.d.ts

@@ -0,0 +1,4 @@
+import { Log } from '@sprucelabs/spruce-skill-utils';
+import { RemoteOptions } from './snapshotter.types.js';
+export declare function gitCommit(mirrorPath: string, log?: Log): Promise<boolean>;
+export declare function gitPush(mirrorPath: string, remote: RemoteOptions, log?: Log): Promise<void>;