@selfchecks/selfchecks 0.1.25 → 0.1.26

package/README.md

@@ -27,7 +27,6 @@ export default defineConfig({
   checks: {
     activated: true,
     frequency: Frequency.EVERY_15M,
-    checkMatch: "**/*.check.ts",
   },
 });
 ```
@@ -51,6 +50,29 @@ new BrowserCheck("homepage", {
 
 The entrypoint is a regular Playwright Test file.
 
+Define an API check with request assertions:
+
+```ts
+import { ApiCheck, AssertionBuilder } from "@selfchecks/selfchecks/constructs";
+
+new ApiCheck("health", {
+  maxResponseTime: 2_000,
+  request: {
+    method: "GET",
+    url: "{{API_URL}}/health",
+    queryParameters: { probe: "selfchecks" },
+    assertions: [
+      AssertionBuilder.statusCode().equals(200),
+      AssertionBuilder.jsonBody("$.data.ok").equals(true),
+    ],
+  },
+});
+```
+
+The Selfchecks CLI executes TypeScript manifests locally and compiles them into
+`DeploymentManifest v1`. Imported helpers, loops, and computed construct definitions
+are supported as long as their final properties belong to the compatibility profile.
+
 ## Checkly-compatible imports
 
 Existing projects can keep supported imports from `checkly` by installing this
@@ -82,9 +104,11 @@ import {
 ```
 
 Compatibility is intentionally limited to these constructs and their exported
-TypeScript types. Other Checkly constructs, CLI commands, cloud APIs, and runtime
-features are not supported. Assertion and alert objects are accepted for source
-compatibility, but Selfchecks does not currently deploy their Checkly configuration.
+TypeScript types. API request assertions and webhook alert channels attached through
+groups are deployed. Unsupported properties produce a compiler error instead of being
+silently ignored. Checkly locations, runtimes, secrets, status pages, maintenance
+windows, alert escalation policies, REST APIs, CLI commands, and cloud runtime
+behavior are not supported.
 
 See the complete [migration guide](https://selfchecks.github.io/getting-started.html#migration)
 and [Selfchecks documentation](https://selfchecks.github.io/getting-started.html).

package/dist/compiler-runtime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compiler-runtime.d.ts.map

package/dist/compiler-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-runtime.d.ts","sourceRoot":"","sources":["../src/compiler-runtime.ts"],"names":[],"mappings":""}

package/dist/compiler-runtime.js

@@ -0,0 +1,473 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const constructCollectorSymbol = Symbol.for("@selfchecks/selfchecks/construct-collector");
+const ignoredDirectories = new Set([
+    ".git",
+    ".next",
+    ".selfchecks",
+    "coverage",
+    "dist",
+    "node_modules",
+    "playwright-report",
+    "test-results",
+]);
+const configFileNames = [
+    "selfchecks.config.ts",
+    "selfchecks.config.mts",
+    "selfchecks.config.js",
+    "selfchecks.config.mjs",
+    "checkly.config.ts",
+    "checkly.config.mts",
+    "checkly.config.js",
+    "checkly.config.mjs",
+];
+const commonCheckKeys = new Set([
+    "activated",
+    "alertChannels",
+    "frequency",
+    "group",
+    "muted",
+    "name",
+    "retryStrategy",
+    "shouldFail",
+    "tags",
+]);
+const groupKeys = new Set([
+    "activated",
+    "alertChannels",
+    "frequency",
+    "muted",
+    "name",
+    "retryStrategy",
+    "shouldFail",
+    "tags",
+]);
+const webhookKeys = new Set([
+    "method",
+    "name",
+    "sendDegraded",
+    "sendFailure",
+    "sendRecovery",
+    "sslExpiry",
+    "template",
+    "url",
+]);
+process.once("message", (message) => {
+    void run(message)
+        .then((manifest) => process.send?.({ manifest, success: true }))
+        .catch((error) => process.send?.({
+        error: error instanceof Error ? error.message : String(error),
+        success: false,
+    }));
+});
+async function run(options) {
+    const configPath = options.configPath
+        ? path.resolve(options.rootDir, options.configPath)
+        : await findConfigPath(options.rootDir);
+    const configModule = configPath
+        ? (await import(pathToFileURL(configPath).href))
+        : undefined;
+    const config = configModule?.default ?? {};
+    const projectName = readRequiredString(config.projectName, "projectName");
+    const logicalId = readRequiredString(config.logicalId, "logicalId");
+    const collector = [];
+    globalThis[constructCollectorSymbol] = collector;
+    try {
+        for (const filePath of await findCheckFiles(options.rootDir)) {
+            await import(pathToFileURL(filePath).href);
+        }
+    }
+    finally {
+        delete globalThis[constructCollectorSymbol];
+    }
+    const groups = new Map(collector
+        .filter((item) => item.kind === "CheckGroup" || item.kind === "CheckGroupV2")
+        .map((item) => [item.logicalId, item]));
+    const channels = new Map(collector
+        .filter((item) => item.kind === "WebhookAlertChannel")
+        .map((item) => [item.logicalId, item]));
+    assertUniqueLogicalIds(collector.filter((item) => item.kind === "ApiCheck" || item.kind === "BrowserCheck"), "check");
+    assertUniqueLogicalIds(collector.filter((item) => item.kind === "CheckGroup" || item.kind === "CheckGroupV2"), "group");
+    assertUniqueLogicalIds(collector.filter((item) => item.kind === "WebhookAlertChannel"), "alert channel");
+    for (const group of groups.values()) {
+        assertSupportedProperties(group, asRecord(group.props), groupKeys);
+    }
+    for (const channel of channels.values()) {
+        assertSupportedProperties(channel, asRecord(channel.props), webhookKeys);
+    }
+    assertSupportedConfigDefaults(config);
+    const checks = collector
+        .filter((item) => item.kind === "ApiCheck" || item.kind === "BrowserCheck")
+        .map((item) => compileCheck(item, config, groups, channels));
+    if (checks.length === 0) {
+        throw new Error(`No Selfchecks definitions were found in ${options.rootDir}.`);
+    }
+    return {
+        alertChannels: [...channels.values()].map(compileWebhookAlertChannel),
+        checks,
+        project: { logicalId, name: projectName },
+        version: 1,
+        warnings: [],
+    };
+}
+async function findConfigPath(rootDir) {
+    const entries = new Set(await readdir(rootDir));
+    const configName = configFileNames.find((name) => entries.has(name));
+    return configName ? path.join(rootDir, configName) : undefined;
+}
+async function findCheckFiles(rootDir) {
+    const files = [];
+    async function visit(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                if (!ignoredDirectories.has(entry.name)) {
+                    await visit(path.join(directory, entry.name));
+                }
+            }
+            else if (entry.isFile() && /\.check\.(?:[cm]?[jt]s)$/.test(entry.name)) {
+                files.push(path.join(directory, entry.name));
+            }
+        }
+    }
+    await visit(rootDir);
+    return files.sort();
+}
+function compileCheck(construct, config, groups, channels) {
+    const type = construct.kind === "ApiCheck" ? "api" : "browser";
+    const ownProps = asRecord(construct.props);
+    const groupLogicalId = getLogicalId(ownProps.group);
+    const group = groupLogicalId ? groups.get(groupLogicalId) : undefined;
+    if (groupLogicalId && !group) {
+        throw new Error(`${construct.kind} ${construct.logicalId} references unknown group: ${groupLogicalId}`);
+    }
+    const groupProps = group ? asRecord(group.props) : {};
+    const groupCheckDefaults = pickGroupCheckDefaults(groupProps);
+    const checkDefaults = asRecord(config.checks);
+    const typeDefaults = type === "browser" ? asRecord(config.checks?.browserChecks) : {};
+    const props = {
+        ...checkDefaults,
+        ...typeDefaults,
+        ...groupCheckDefaults,
+        ...ownProps,
+    };
+    const allowedKeys = new Set(commonCheckKeys);
+    if (type === "browser") {
+        allowedKeys.add("code");
+    }
+    else {
+        allowedKeys.add("degradedResponseTime");
+        allowedKeys.add("maxResponseTime");
+        allowedKeys.add("request");
+    }
+    assertSupportedProperties(construct, ownProps, allowedKeys);
+    const frequency = normalizeFrequency(props.frequency, construct.logicalId);
+    const tags = normalizeStrings(props.tags);
+    const retryStrategy = normalizeRetryStrategy(props.retryStrategy, construct.logicalId);
+    const alertChannelLogicalIds = normalizeReferences(ownProps.alertChannels ?? groupProps.alertChannels ?? checkDefaults.alertChannels);
+    const unknownAlertChannel = alertChannelLogicalIds.find((logicalId) => !channels.has(logicalId));
+    if (unknownAlertChannel) {
+        throw new Error(`${construct.kind} ${construct.logicalId} references unknown alert channel: ${unknownAlertChannel}`);
+    }
+    const base = {
+        alertChannelLogicalIds,
+        enabled: props.activated !== false,
+        key: construct.logicalId,
+        muted: props.muted === true,
+        name: typeof props.name === "string" ? props.name : construct.logicalId,
+        shouldFail: props.shouldFail === true,
+        tags,
+        type,
+        ...(frequency ? { frequency } : {}),
+        ...(group
+            ? {
+                groupKey: group.logicalId,
+                groupName: typeof groupProps.name === "string" ? groupProps.name : group.logicalId,
+            }
+            : {}),
+        ...(retryStrategy ? { retryStrategy } : {}),
+    };
+    if (type === "api") {
+        base.request = compileRequest(props.request, construct.logicalId);
+        base.degradedResponseTime = optionalNonNegativeNumber(props.degradedResponseTime, "degradedResponseTime", construct.logicalId);
+        base.maxResponseTime = optionalNonNegativeNumber(props.maxResponseTime, "maxResponseTime", construct.logicalId);
+    }
+    else {
+        const code = asRecord(props.code);
+        const entrypoint = code.entrypoint;
+        if (typeof entrypoint !== "string" || !entrypoint.trim()) {
+            throw new Error(`BrowserCheck ${construct.logicalId} requires code.entrypoint.`);
+        }
+        base.entrypoint = entrypoint;
+    }
+    return base;
+}
+function pickGroupCheckDefaults(props) {
+    return Object.fromEntries(["activated", "frequency", "muted", "retryStrategy", "shouldFail", "tags"].flatMap((key) => (key in props ? [[key, props[key]]] : [])));
+}
+function assertSupportedConfigDefaults(config) {
+    const defaults = asRecord(config.checks);
+    const browserDefaults = asRecord(config.checks?.browserChecks);
+    const defaultKeys = new Set(commonCheckKeys);
+    defaultKeys.delete("group");
+    defaultKeys.add("browserChecks");
+    defaultKeys.add("degradedResponseTime");
+    defaultKeys.add("maxResponseTime");
+    for (const key of Object.keys(defaults)) {
+        if (!defaultKeys.has(key)) {
+            throw new Error(`Selfchecks configuration uses unsupported checks.${key}.`);
+        }
+    }
+    const browserKeys = new Set(commonCheckKeys);
+    browserKeys.delete("alertChannels");
+    browserKeys.delete("group");
+    for (const key of Object.keys(browserDefaults)) {
+        if (!browserKeys.has(key)) {
+            throw new Error(`Selfchecks configuration uses unsupported checks.browserChecks.${key}.`);
+        }
+    }
+}
+function compileRequest(value, logicalId) {
+    const request = asRecord(value);
+    const allowedKeys = new Set([
+        "assertions",
+        "basicAuth",
+        "body",
+        "bodyType",
+        "followRedirects",
+        "headers",
+        "method",
+        "queryParameters",
+        "url",
+    ]);
+    for (const key of Object.keys(request)) {
+        if (!allowedKeys.has(key)) {
+            throw new Error(`ApiCheck ${logicalId} request uses unsupported property: ${key}`);
+        }
+    }
+    if (typeof request.method !== "string" || typeof request.url !== "string") {
+        throw new Error(`ApiCheck ${logicalId} requires request.method and request.url.`);
+    }
+    const assertions = compileAssertions(request.assertions, logicalId);
+    const bodyType = request.bodyType;
+    if (bodyType !== undefined &&
+        !["FORM", "GRAPHQL", "JSON", "NONE", "RAW"].includes(String(bodyType))) {
+        throw new Error(`ApiCheck ${logicalId} has unsupported request.bodyType.`);
+    }
+    return {
+        assertions,
+        headers: normalizeKeyValuePairs(request.headers),
+        method: request.method.toUpperCase(),
+        queryParameters: normalizeKeyValuePairs(request.queryParameters),
+        url: request.url,
+        ...(typeof request.body === "string" ? { body: request.body } : {}),
+        ...(typeof bodyType === "string" ? { bodyType: bodyType } : {}),
+        ...(typeof request.followRedirects === "boolean"
+            ? { followRedirects: request.followRedirects }
+            : {}),
+        ...(isBasicAuth(request.basicAuth) ? { basicAuth: request.basicAuth } : {}),
+    };
+}
+function compileWebhookAlertChannel(construct) {
+    const props = asRecord(construct.props);
+    const url = props.url instanceof URL ? props.url.toString() : props.url;
+    if (typeof url !== "string") {
+        throw new Error(`WebhookAlertChannel ${construct.logicalId} requires a URL.`);
+    }
+    const method = typeof props.method === "string" ? props.method.toUpperCase() : "POST";
+    if (!["DELETE", "GET", "PATCH", "POST", "PUT"].includes(method)) {
+        throw new Error(`WebhookAlertChannel ${construct.logicalId} uses unsupported method: ${method}`);
+    }
+    return {
+        adapter: "generic",
+        logicalId: construct.logicalId,
+        method: method,
+        name: typeof props.name === "string" ? props.name : construct.logicalId,
+        sendDegraded: props.sendDegraded === true,
+        sendFailure: props.sendFailure !== false,
+        sendRecovery: props.sendRecovery !== false,
+        sslExpiry: props.sslExpiry === true,
+        ...(typeof props.template === "string" ? { template: props.template } : {}),
+        url,
+    };
+}
+function assertSupportedProperties(construct, props, allowedKeys) {
+    for (const key of Object.keys(props)) {
+        if (!allowedKeys.has(key)) {
+            throw new Error(`${construct.kind} ${construct.logicalId} uses unsupported property: ${key}`);
+        }
+    }
+}
+function assertUniqueLogicalIds(constructs, label) {
+    const seen = new Set();
+    for (const construct of constructs) {
+        if (seen.has(construct.logicalId)) {
+            throw new Error(`Duplicate ${label} logicalId: ${construct.logicalId}`);
+        }
+        seen.add(construct.logicalId);
+    }
+}
+function compileAssertions(value, logicalId) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`ApiCheck ${logicalId} request.assertions must be an array.`);
+    }
+    const sources = new Set([
+        "HEADERS",
+        "JSON_BODY",
+        "RESPONSE_TIME",
+        "STATUS_CODE",
+        "TEXT_BODY",
+    ]);
+    const comparisons = new Set([
+        "CONTAINS",
+        "EQUALS",
+        "GREATER_THAN",
+        "HAS_KEY",
+        "HAS_VALUE",
+        "IS_EMPTY",
+        "IS_NOT_NULL",
+        "IS_NULL",
+        "LESS_THAN",
+        "NOT_CONTAINS",
+        "NOT_EMPTY",
+        "NOT_EQUALS",
+        "NOT_HAS_KEY",
+        "NOT_HAS_VALUE",
+    ]);
+    return value.map((item, index) => {
+        const assertion = asRecord(item);
+        for (const key of Object.keys(assertion)) {
+            if (!["comparison", "property", "source", "target"].includes(key)) {
+                throw new Error(`ApiCheck ${logicalId} assertion ${index} uses unsupported property: ${key}`);
+            }
+        }
+        if (!sources.has(String(assertion.source))) {
+            throw new Error(`ApiCheck ${logicalId} assertion ${index} uses unsupported source: ${String(assertion.source)}`);
+        }
+        if (!comparisons.has(String(assertion.comparison))) {
+            throw new Error(`ApiCheck ${logicalId} assertion ${index} uses unsupported comparison: ${String(assertion.comparison)}`);
+        }
+        if (assertion.property !== undefined && typeof assertion.property !== "string") {
+            throw new Error(`ApiCheck ${logicalId} assertion ${index} property must be a string.`);
+        }
+        return { ...assertion };
+    });
+}
+function normalizeFrequency(value, logicalId) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`Check ${logicalId} requires a positive minute frequency.`);
+    }
+    return { intervalMinutes: value };
+}
+function normalizeRetryStrategy(value, logicalId) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const strategy = asRecord(value);
+    const supportedTypes = new Set([
+        "EXPONENTIAL",
+        "FIXED",
+        "LINEAR",
+        "NO_RETRIES",
+        "SINGLE_RETRY",
+    ]);
+    if (!supportedTypes.has(String(strategy.type))) {
+        throw new Error(`Check ${logicalId} uses unsupported retry strategy type.`);
+    }
+    for (const key of Object.keys(strategy)) {
+        if (![
+            "baseBackoffSeconds",
+            "maxDurationSeconds",
+            "maxRetries",
+            "onlyOn",
+            "sameRegion",
+            "type",
+        ].includes(key)) {
+            throw new Error(`Check ${logicalId} retry strategy uses unsupported property: ${key}`);
+        }
+    }
+    for (const key of [
+        "baseBackoffSeconds",
+        "maxDurationSeconds",
+        "maxRetries",
+    ]) {
+        const item = strategy[key];
+        if (item !== undefined && (!Number.isSafeInteger(item) || Number(item) < 0)) {
+            throw new Error(`Check ${logicalId} retry strategy ${key} must be non-negative.`);
+        }
+    }
+    if (typeof strategy.maxRetries === "number" && strategy.maxRetries > 10) {
+        throw new Error(`Check ${logicalId} retry strategy maxRetries cannot exceed 10.`);
+    }
+    if (strategy.maxDurationSeconds === 0) {
+        throw new Error(`Check ${logicalId} retry strategy maxDurationSeconds must be positive.`);
+    }
+    if (strategy.onlyOn !== undefined &&
+        strategy.onlyOn !== "NETWORK_ERROR" &&
+        (!Array.isArray(strategy.onlyOn) ||
+            !strategy.onlyOn.every((item) => typeof item === "string" && item.length > 0))) {
+        throw new Error(`Check ${logicalId} retry strategy onlyOn is invalid.`);
+    }
+    if (strategy.sameRegion !== undefined && typeof strategy.sameRegion !== "boolean") {
+        throw new Error(`Check ${logicalId} retry strategy sameRegion must be boolean.`);
+    }
+    return { ...strategy };
+}
+function normalizeKeyValuePairs(value) {
+    if (Array.isArray(value)) {
+        return Object.fromEntries(value.flatMap((item) => {
+            const pair = asRecord(item);
+            return typeof pair.key === "string" && typeof pair.value === "string"
+                ? [[pair.key, pair.value]]
+                : [];
+        }));
+    }
+    return Object.fromEntries(Object.entries(asRecord(value)).flatMap(([key, item]) => typeof item === "string" ? [[key, item]] : []));
+}
+function normalizeReferences(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((item) => {
+        const logicalId = getLogicalId(item);
+        return logicalId ? [logicalId] : [];
+    });
+}
+function normalizeStrings(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return [...new Set(value.filter((item) => typeof item === "string"))];
+}
+function getLogicalId(value) {
+    const record = asRecord(value);
+    return typeof record.logicalId === "string" ? record.logicalId : undefined;
+}
+function readRequiredString(value, name) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`Selfchecks configuration requires ${name}.`);
+    }
+    return value.trim();
+}
+function optionalNonNegativeNumber(value, property, logicalId) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new Error(`ApiCheck ${logicalId} ${property} must be non-negative.`);
+    }
+    return value;
+}
+function isBasicAuth(value) {
+    const auth = asRecord(value);
+    return typeof auth.username === "string" && typeof auth.password === "string";
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}

package/dist/compiler.d.ts

@@ -0,0 +1,53 @@
+import type { Assertion, Request, RetryStrategy, WebhookAlertChannelProps } from "./constructs.js";
+export type CompiledApiRequest = Omit<Request, "assertions" | "headers" | "queryParameters"> & {
+    assertions: Assertion[];
+    headers: Record<string, string>;
+    queryParameters: Record<string, string>;
+};
+export type CompiledCheck = {
+    alertChannelLogicalIds: string[];
+    degradedResponseTime?: number;
+    enabled: boolean;
+    entrypoint?: string;
+    frequency?: {
+        intervalMinutes: number;
+    };
+    groupKey?: string;
+    groupName?: string;
+    key: string;
+    maxResponseTime?: number;
+    muted: boolean;
+    name: string;
+    request?: CompiledApiRequest;
+    retryStrategy?: RetryStrategy;
+    shouldFail: boolean;
+    tags: string[];
+    type: "api" | "browser";
+};
+export type CompiledWebhookAlertChannel = Omit<WebhookAlertChannelProps, "method" | "name" | "sendDegraded" | "sendFailure" | "sendRecovery" | "sslExpiry" | "url"> & {
+    adapter: "generic";
+    logicalId: string;
+    method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    name: string;
+    sendDegraded: boolean;
+    sendFailure: boolean;
+    sendRecovery: boolean;
+    sslExpiry: boolean;
+    url: string;
+};
+export type DeploymentManifest = {
+    alertChannels: CompiledWebhookAlertChannel[];
+    checks: CompiledCheck[];
+    project: {
+        logicalId: string;
+        name: string;
+    };
+    version: 1;
+    warnings: string[];
+};
+export type CompileProjectOptions = {
+    configPath?: string;
+    rootDir: string;
+};
+export declare function compileProject(options: CompileProjectOptions): Promise<DeploymentManifest>;
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,SAAS,EACT,OAAO,EACP,aAAa,EACb,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,OAAO,EACP,YAAY,GAAG,SAAS,GAAG,iBAAiB,CAC7C,GAAG;IACF,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,sBAAsB,EAAE,MAAM,EAAE,CAAC;IACjC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC5C,wBAAwB,EACtB,QAAQ,GACR,MAAM,GACN,cAAc,GACd,aAAa,GACb,cAAc,GACd,WAAW,GACX,KAAK,CACR,GAAG;IACF,OAAO,EAAE,SAAS,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,QAAQ,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,aAAa,EAAE,2BAA2B,EAAE,CAAC;IAC7C,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,OAAO,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,OAAO,EAAE,CAAC,CAAC;IACX,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAMF,wBAAsB,cAAc,CAClC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAiD7B"}

package/dist/compiler.js

@@ -0,0 +1,43 @@
+import { fork } from "node:child_process";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+export async function compileProject(options) {
+    const moduleUrl = import.meta.url.startsWith("file:")
+        ? import.meta.url
+        : pathToFileURL(path.join(process.cwd(), "packages/checkly-compat/src/compiler.ts"))
+            .href;
+    const runtimePath = fileURLToPath(new URL(moduleUrl.endsWith(".ts") ? "./compiler-runtime.ts" : "./compiler-runtime.js", moduleUrl));
+    const tsxLoader = pathToFileURL(createRequire(moduleUrl).resolve("tsx")).href;
+    return new Promise((resolve, reject) => {
+        const child = fork(runtimePath, [], {
+            cwd: options.rootDir,
+            env: process.env,
+            execArgv: ["--import", tsxLoader],
+            silent: true,
+        });
+        let stderr = "";
+        let settled = false;
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("message", (message) => {
+            settled = true;
+            child.disconnect();
+            if (message.success) {
+                resolve(message.manifest);
+            }
+            else {
+                reject(new Error(message.error));
+            }
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (!settled) {
+                reject(new Error(stderr.trim() || `Selfchecks project compiler exited with status ${code}.`));
+            }
+        });
+        child.send(options);
+    });
+}

package/dist/constructs.d.ts

@@ -1,39 +1,65 @@
 export type FrequencyValue = number;
 export declare const Frequency: {
+    readonly EVERY_1H: 60;
+    readonly EVERY_1M: 1;
     readonly EVERY_10M: 10;
     readonly EVERY_12H: number;
     readonly EVERY_15M: 15;
     readonly EVERY_24H: number;
     readonly EVERY_2H: number;
+    readonly EVERY_2M: 2;
     readonly EVERY_30M: 30;
     readonly EVERY_3H: number;
+    readonly EVERY_5M: 5;
     readonly EVERY_6H: number;
 };
 export type Assertion = {
-    operator: "contains" | "equals" | "isEmpty" | "isNotNull";
-    source: string;
+    comparison: "CONTAINS" | "EQUALS" | "GREATER_THAN" | "HAS_KEY" | "HAS_VALUE" | "IS_EMPTY" | "IS_NOT_NULL" | "IS_NULL" | "LESS_THAN" | "NOT_CONTAINS" | "NOT_EMPTY" | "NOT_EQUALS" | "NOT_HAS_KEY" | "NOT_HAS_VALUE";
+    property?: string;
+    source: "HEADERS" | "JSON_BODY" | "RESPONSE_TIME" | "STATUS_CODE" | "TEXT_BODY";
     target?: unknown;
 };
 type AssertionChain = {
     contains(value: unknown): Assertion;
     equals(value: unknown): Assertion;
+    greaterThan(value: number): Assertion;
+    hasKey(value: string): Assertion;
+    hasValue(value: unknown): Assertion;
     isEmpty(): Assertion;
     isNotNull(): Assertion;
+    isNull(): Assertion;
+    lessThan(value: number): Assertion;
+    notContains(value: unknown): Assertion;
+    notEmpty(): Assertion;
+    notEquals(value: unknown): Assertion;
+    notHasKey(value: string): Assertion;
+    notHasValue(value: unknown): Assertion;
 };
 export declare const AssertionBuilder: {
-    jsonBody: (path: string) => AssertionChain;
+    headers: (property?: string) => AssertionChain;
+    jsonBody: (property?: string) => AssertionChain;
+    responseTime: () => AssertionChain;
     statusCode: () => AssertionChain;
-    textBody: () => AssertionChain;
+    textBody: (property?: string) => AssertionChain;
+};
+export type KeyValuePair = {
+    key: string;
+    locked?: boolean;
+    secret?: boolean;
+    value: string;
 };
 export type Request = {
     assertions?: Assertion[];
+    basicAuth?: {
+        password: string;
+        username: string;
+    };
     body?: string;
+    bodyType?: "FORM" | "GRAPHQL" | "JSON" | "NONE" | "RAW";
     followRedirects?: boolean;
-    headers?: Array<{
-        key: string;
-        value: string;
-    }> | Record<string, string>;
+    headers?: KeyValuePair[] | Record<string, string>;
     method: string;
+    queryParameters?: KeyValuePair[] | Record<string, string>;
     skipSSL?: boolean;
     url: string;
 };
@@ -41,19 +67,21 @@ export type RetryStrategy = {
     baseBackoffSeconds?: number;
     maxDurationSeconds?: number;
     maxRetries?: number;
-    onlyOn?: string[];
+    onlyOn?: "NETWORK_ERROR" | string[];
     sameRegion?: boolean;
-    type: "EXPONENTIAL" | "FIXED" | "LINEAR" | "NO_RETRIES";
+    type: "EXPONENTIAL" | "FIXED" | "LINEAR" | "NO_RETRIES" | "SINGLE_RETRY";
 };
 type RetryStrategyOptions = Omit<RetryStrategy, "type">;
 export declare const RetryStrategyBuilder: {
-    exponentialStrategy: (options: RetryStrategyOptions) => RetryStrategy;
-    fixedStrategy: (options: RetryStrategyOptions) => RetryStrategy;
-    linearStrategy: (options: RetryStrategyOptions) => RetryStrategy;
+    exponentialStrategy: (options?: RetryStrategyOptions) => RetryStrategy;
+    fixedStrategy: (options?: RetryStrategyOptions) => RetryStrategy;
+    linearStrategy: (options?: RetryStrategyOptions) => RetryStrategy;
     noRetries: () => RetryStrategy;
+    singleRetry: (options?: Pick<RetryStrategyOptions, "baseBackoffSeconds" | "onlyOn" | "sameRegion">) => RetryStrategy;
 };
 type SharedCheckProps = {
     activated?: boolean;
+    alertChannels?: WebhookAlertChannel[];
     environmentVariables?: Array<{
         key: string;
         value: string;
@@ -64,6 +92,7 @@ type SharedCheckProps = {
     name?: string;
     retryStrategy?: RetryStrategy;
     runParallel?: boolean;
+    shouldFail?: boolean;
     tags?: string[];
 };
 export type ApiCheckProps = SharedCheckProps & {
@@ -75,7 +104,6 @@ export type BrowserCheckProps = SharedCheckProps & {
     code: {
         entrypoint: string;
     };
-    shouldFail?: boolean;
 };
 export type CheckGroupV2Props = SharedCheckProps & {
     alertChannels?: WebhookAlertChannel[];
@@ -83,6 +111,11 @@ export type CheckGroupV2Props = SharedCheckProps & {
     locations?: string[];
     privateLocations?: string[];
 };
+export type CollectedConstruct = {
+    kind: string;
+    logicalId: string;
+    props: unknown;
+};
 declare class Construct<Props> {
     readonly logicalId: string;
     readonly props: Props;

package/dist/constructs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constructs.d.ts","sourceRoot":"","sources":["../src/constructs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constructs.d.ts","sourceRoot":"","sources":["../src/constructs.ts"],"names":[],"mappings":"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"}

package/dist/constructs.js

@@ -1,47 +1,76 @@
 export const Frequency = {
+    EVERY_1H: 60,
+    EVERY_1M: 1,
     EVERY_10M: 10,
     EVERY_12H: 12 * 60,
     EVERY_15M: 15,
     EVERY_24H: 24 * 60,
     EVERY_2H: 2 * 60,
+    EVERY_2M: 2,
     EVERY_30M: 30,
     EVERY_3H: 3 * 60,
+    EVERY_5M: 5,
     EVERY_6H: 6 * 60,
 };
-function assertionChain(source) {
+function assertionChain(source, property) {
+    const assertion = (comparison, target) => ({
+        comparison,
+        ...(property ? { property } : {}),
+        source,
+        ...(target !== undefined ? { target } : {}),
+    });
     return {
-        contains: (target) => ({ operator: "contains", source, target }),
-        equals: (target) => ({ operator: "equals", source, target }),
-        isEmpty: () => ({ operator: "isEmpty", source }),
-        isNotNull: () => ({ operator: "isNotNull", source }),
+        contains: (target) => assertion("CONTAINS", target),
+        equals: (target) => assertion("EQUALS", target),
+        greaterThan: (target) => assertion("GREATER_THAN", target),
+        hasKey: (target) => assertion("HAS_KEY", target),
+        hasValue: (target) => assertion("HAS_VALUE", target),
+        isEmpty: () => assertion("IS_EMPTY"),
+        isNotNull: () => assertion("IS_NOT_NULL"),
+        isNull: () => assertion("IS_NULL"),
+        lessThan: (target) => assertion("LESS_THAN", target),
+        notContains: (target) => assertion("NOT_CONTAINS", target),
+        notEmpty: () => assertion("NOT_EMPTY"),
+        notEquals: (target) => assertion("NOT_EQUALS", target),
+        notHasKey: (target) => assertion("NOT_HAS_KEY", target),
+        notHasValue: (target) => assertion("NOT_HAS_VALUE", target),
     };
 }
 export const AssertionBuilder = {
-    jsonBody: (path) => assertionChain(`jsonBody:${path}`),
-    statusCode: () => assertionChain("statusCode"),
-    textBody: () => assertionChain("textBody"),
+    headers: (property) => assertionChain("HEADERS", property),
+    jsonBody: (property) => assertionChain("JSON_BODY", property),
+    responseTime: () => assertionChain("RESPONSE_TIME"),
+    statusCode: () => assertionChain("STATUS_CODE"),
+    textBody: (property) => assertionChain("TEXT_BODY", property),
 };
 export const RetryStrategyBuilder = {
-    exponentialStrategy: (options) => ({
+    exponentialStrategy: (options = {}) => ({
         ...options,
         type: "EXPONENTIAL",
     }),
-    fixedStrategy: (options) => ({
+    fixedStrategy: (options = {}) => ({
         ...options,
         type: "FIXED",
     }),
-    linearStrategy: (options) => ({
+    linearStrategy: (options = {}) => ({
         ...options,
         type: "LINEAR",
     }),
     noRetries: () => ({ maxRetries: 0, type: "NO_RETRIES" }),
+    singleRetry: (options = {}) => ({ ...options, type: "SINGLE_RETRY" }),
 };
+const constructCollectorSymbol = Symbol.for("@selfchecks/selfchecks/construct-collector");
+function collectConstruct(construct) {
+    const collector = globalThis[constructCollectorSymbol];
+    collector?.push(construct);
+}
 class Construct {
     logicalId;
     props;
     constructor(logicalId, props) {
         this.logicalId = logicalId;
         this.props = props;
+        collectConstruct({ kind: this.constructor.name, logicalId, props });
     }
 }
 export class ApiCheck extends Construct {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selfchecks/selfchecks",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Checkly-compatible constructs supported by Selfchecks",
   "license": "Elastic-2.0",
   "type": "module",
@@ -19,12 +19,19 @@
     "./constructs": {
       "types": "./dist/constructs.d.ts",
       "import": "./dist/constructs.js"
+    },
+    "./compiler": {
+      "types": "./dist/compiler.d.ts",
+      "import": "./dist/compiler.js"
     }
   },
   "typesVersions": {
     "*": {
       "constructs": [
         "dist/constructs.d.ts"
+      ],
+      "compiler": [
+        "dist/compiler.d.ts"
       ]
     }
   },
@@ -41,11 +48,14 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "vitest run --root ../.. packages/checkly-compat/src/index.test.ts",
+    "test": "vitest run --root ../.. packages/checkly-compat/src",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "tsx": "^4.20.3"
   }
 }