@sanity/runtime-cli 14.7.2 → 14.8.0

package/dist/cores/functions/test.js

@@ -138,7 +138,7 @@ export async function functionTestCore(options) {
                 event: 'scheduled',
             };
         const spinner = log.ora('Executing function...').start();
-        const { json, logs, error } = await testAction(resource, invokeOptions, contextOptions, {
+        const { json: response, logs, error, } = await testAction(resource, invokeOptions, contextOptions, {
             timeout: timeout ? timeout : resource.timeout,
         });
         if (error) {
@@ -151,11 +151,11 @@ export async function functionTestCore(options) {
         spinner.succeed('Function execution succeeded.');
         log('Logs:');
         log(logs || '');
-        if (json) {
+        if (response) {
             log('Response:');
-            log(JSON.stringify(json, null, 2));
+            log(JSON.stringify(response, null, 2));
         }
-        return { success: true };
+        return { success: true, json: { response, logs } };
     }
     catch (error) {
         return {

package/dist/cores/index.d.ts

@@ -7,7 +7,7 @@ export interface CoreConfig {
     /** The CLI binary name. */
     bin: string;
     /** The log output function. */
-    log: ReturnType<typeof Logger>;
+    log: Logger;
     /** Enable resource validation during parsing */
     validateResources?: boolean;
     /** Path to a specific Blueprint file or directory */
@@ -25,7 +25,10 @@ export interface DeployedBlueprintConfig extends BlueprintConfig {
     deployedStack: Stack;
 }
 export type CoreResult = {
-    /** Arbitrary data for isolated testing */
+    /**
+     * Internal data for isolated testing and debugging.
+     * Not returned to users! Use `json` for structured output via oclif's `--json` flag.
+     */
     data?: Record<string, unknown>;
 } & ({
     /** Something went wrong. */
@@ -40,6 +43,10 @@ export type CoreResult = {
     /** The streaming function, if the operation is streaming. */
     streaming?: Promise<void>;
     error?: never;
+    /**
+     * Structured data returned to the user when `--json` is passed.
+     * Commands should return this value from `run()` for oclif to serialize.
+     */
     json?: Record<string, unknown>;
 });
 type InitBlueprintConfigParams = CoreConfig & ({

package/dist/cores/index.js

@@ -1,7 +1,6 @@
 import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import { getStack, resolveStackIdByNameOrId } from '../actions/blueprints/stacks.js';
 import { presentBlueprintParserErrors } from '../utils/display/errors.js';
-import { niceId } from '../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../utils/validated-token.js';
 export * as blueprintsCores from './blueprints/index.js';
 export * as functionsCores from './functions/index.js';
@@ -55,12 +54,14 @@ export async function initDeployedBlueprintConfig(config) {
         config.log(`Incomplete configuration. Run \`${config.bin} blueprints doctor\` for diagnostics.`);
         return { ok: false, error: 'Missing Stack deployment configuration for Blueprint' };
     }
+    const spinner = config.log.ora('Loading Stack deployment...').start();
     const stackResponse = await getStack({ stackId, auth, logger: config.log });
     if (!stackResponse.ok) {
-        config.log(`Could not retrieve Stack deployment info for ${niceId(stackId)}.`);
+        spinner.fail('Could not load Stack deployment');
         config.log(`Run \`${config.bin} blueprints doctor\` for diagnostics.`);
         return { ok: false, error: 'Missing Stack deployment' };
     }
+    spinner.stop().clear();
     return {
         ok: true,
         value: {

package/dist/server/app.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../utils/logger.js';
 import { type InvokeExecutionOptions } from '../utils/types.js';
-declare const app: (host: string, port: number, logger: ReturnType<typeof Logger>, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>) => void;
+declare const app: (host: string, port: number, logger: Logger, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>) => void;
 declare function parseDocumentUrl(url: string): {
     projectId: string;
     dataset: string;

package/dist/server/handlers/invoke.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '../../utils/logger.js';
 import type { InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadMetadata } from '../../utils/types.js';
-export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: InvokePayloadMetadata, context: InvokeContextOptions, logger: ReturnType<typeof Logger>, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
+export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: InvokePayloadMetadata, context: InvokeContextOptions, logger: Logger, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
     timings: Record<string, number>;
 }>;

package/dist/utils/display/prompt.d.ts

@@ -10,7 +10,7 @@ export declare function promptForProject({ token, knownOrganizationId, knownProj
     token: string;
     knownOrganizationId?: string;
     knownProjectId?: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<{
     projectId: string;
     displayName: string;
@@ -26,7 +26,7 @@ export declare function promptForProject({ token, knownOrganizationId, knownProj
 export declare function promptForStack({ projectId, token, logger, }: {
     projectId: string;
     token: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<{
     stackId: string;
     name: string;

package/dist/utils/display/prompt.js

@@ -95,7 +95,7 @@ export async function promptForStack({ projectId, token, logger, }) {
         stackChoices.push({ name: styleText('bold', 'New Stack ✨'), value: NEW_STACK_ID });
         stackChoices.push(new Separator(styleText('underline', 'Use an existing Stack:')));
         stackChoices.push(...stacks.map((s) => ({
-            name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} res)`)}`,
+            name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
             value: s.id,
         })));
         pickedStackId = await select({

package/dist/utils/functions/fetch-document.d.ts

@@ -1,5 +1,5 @@
 import { type ClientConfig } from '@sanity/client';
 import type { Logger } from '../logger.js';
 import type { FetchConfig } from '../types.js';
-export declare function fetchDocument(documentId: string, { projectId, dataset, useCdn, apiVersion, apiHost, token }: ClientConfig, logger: ReturnType<typeof Logger>): Promise<Record<string, unknown>>;
-export declare function fetchAsset(documentId: string, { mediaLibraryId, apiVersion, apiHost, token }: FetchConfig, logger: ReturnType<typeof Logger>): Promise<Record<string, unknown>>;
+export declare function fetchDocument(documentId: string, { projectId, dataset, useCdn, apiVersion, apiHost, token }: ClientConfig, logger: Logger): Promise<Record<string, unknown>>;
+export declare function fetchAsset(documentId: string, { mediaLibraryId, apiVersion, apiHost, token }: FetchConfig, logger: Logger): Promise<Record<string, unknown>>;

package/dist/utils/functions/prepare-asset.d.ts

@@ -1,11 +1,6 @@
-import type { CollectionFunction, FunctionResource, InstallerType } from '../types.js';
+import type { AssetPrepResult, CollectionFunction, FunctionResource, InstallerType } from '../types.js';
 export declare function prepareAsset({ resource, }: {
     resource: FunctionResource | CollectionFunction;
 }, { installer }?: {
     installer?: InstallerType;
-}): Promise<{
-    success: boolean;
-    outputPath?: string;
-    cleanup?: () => Promise<void>;
-    error?: string;
-}>;
+}): Promise<AssetPrepResult>;

package/dist/utils/functions/prepare-asset.js

@@ -29,7 +29,7 @@ export async function prepareAsset({ resource, }, { installer } = {}) {
             wasBundled = result.bundled;
         }
         catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : `${err}` };
+            return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
         }
     }
     const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
@@ -45,7 +45,7 @@ export async function prepareAsset({ resource, }, { installer } = {}) {
         return { success: true, outputPath: functionPath, cleanup };
     }
     catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : `${err}` };
+        return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
     }
 }
 /**

package/dist/utils/logger.d.ts

@@ -2,6 +2,7 @@ import ora from 'ora';
 export declare function Logger(log: (msg: string) => void, flags?: {
     verbose?: boolean;
     trace?: boolean;
+    json?: boolean;
 }): {
     (msg: string): void;
     trace(formatter: unknown, ...args: unknown[]): false | void;
@@ -11,3 +12,4 @@ export declare function Logger(log: (msg: string) => void, flags?: {
     error(formatter: unknown, ...args: unknown[]): false | void;
     ora: typeof ora;
 };
+export type Logger = ReturnType<typeof Logger>;

package/dist/utils/logger.js

@@ -19,6 +19,8 @@ export function Logger(log, flags = {}) {
     logger.warn = (formatter, ...args) => level <= LogLevel.WARN && logger(format(formatter, ...args));
     logger.error = (formatter, ...args) => level <= LogLevel.ERROR && logger(format(formatter, ...args));
     const oraWrapper = (opts) => {
+        if (flags.json)
+            return createOraLineLoggingWrapper(opts, logger);
         if (level >= LogLevel.INFO)
             return ora(opts);
         return createOraLineLoggingWrapper(opts, logger);

package/dist/utils/other/github.d.ts

@@ -1,3 +1,3 @@
 import type { Logger } from '../logger.js';
 export declare const GITHUB_API_URL = "https://api.github.com";
-export declare function gitHubRequest(path: string, logger: ReturnType<typeof Logger>): Promise<Response>;
+export declare function gitHubRequest(path: string, logger: Logger): Promise<Response>;

package/dist/utils/other/npmjs.d.ts

@@ -1,2 +1,2 @@
 import type { Logger } from '../logger.js';
-export declare function getLatestNpmVersion(pkg: string, logger: ReturnType<typeof Logger>): Promise<string>;
+export declare function getLatestNpmVersion(pkg: string, logger: Logger): Promise<string>;

package/dist/utils/traced-fetch.d.ts

@@ -32,4 +32,4 @@ export interface TracedFetchOptions {
  * const response = await tracedFetch('https://api.example.com/data')
  * ```
  */
-export declare function createTracedFetch(logger: ReturnType<typeof Logger>, options?: TracedFetchOptions): typeof fetch;
+export declare function createTracedFetch(logger: Logger, options?: TracedFetchOptions): typeof fetch;

package/dist/utils/types.d.ts

@@ -10,6 +10,11 @@ export type Result<T, E = string> = {
     ok: false;
     error: E;
 };
+/** Base shape for API action responses */
+export interface ActionResponse {
+    ok: boolean;
+    error: string | null;
+}
 /** @internal */
 export interface AuthParams {
     token: string;
@@ -58,17 +63,17 @@ export interface BlueprintResourceRecord extends BlueprintResource {
 export interface DeployedResource extends BlueprintResourceRecord {
     externalId: string;
 }
-export declare function isLocalFunctionResource(r: BlueprintResource): r is FunctionResourceBase;
+export declare function isLocalFunctionResource(r: BlueprintResource): boolean;
 export declare function isDocumentFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceDocument;
 export declare function isMediaLibraryAssetFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceMediaLibraryAsset;
 export declare function isScheduleFunctionResource<T extends BlueprintResource>(r: T): r is T & FunctionResourceSchedule;
-export declare function isLocalFunctionCollection<T extends BlueprintResource>(r: T): r is T & FunctionsCollection;
 export declare function isScheduleEvent(e: unknown): e is FunctionResourceScheduleEvent;
 export declare function isCorsOriginResource(r: unknown): r is BlueprintCorsOriginResource;
 export declare function isProjectResource(r: unknown): r is BlueprintProjectResource;
 export declare function isRobotResource(r: unknown): r is BlueprintRobotResource;
 export declare function isRoleResource(r: unknown): r is BlueprintRoleResource;
 export declare function isDatasetResource(r: unknown): r is BlueprintDatasetResource;
+export declare function isStudioResource(r: unknown): boolean;
 export declare function isWebhookResource(r: unknown): r is BlueprintDocumentWebhookResource;
 /** @internal */
 export type FunctionResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset | FunctionResourceSchedule | FunctionResourceBase;
@@ -258,4 +263,13 @@ export declare interface FetchConfig {
 }
 export declare const INSTALLER_OPTIONS: readonly ["npm", "pnpm", "yarn"];
 export type InstallerType = 'npm' | 'pnpm' | 'yarn';
+export type AssetPrepResult = {
+    success: true;
+    outputPath: string;
+    cleanup: () => Promise<void>;
+} | {
+    success: false;
+    cleanup: () => Promise<void>;
+    error: string;
+};
 export {};

package/dist/utils/types.js

@@ -1,9 +1,9 @@
 import { validateCorsOrigin, validateDataset, validateDocumentWebhook, validateProject, validateRobot, validateRole, } from '@sanity/blueprints';
 import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PREFIX, SANITY_FUNCTION_SCHEDULED, } from '../constants.js';
-// type narrowing with predicate functions
 export function isLocalFunctionResource(r) {
     return r.type.startsWith(SANITY_FUNCTION_PREFIX);
 }
+// type narrowing with predicate functions
 export function isDocumentFunctionResource(r) {
     return r.type === SANITY_FUNCTION_DOCUMENT;
 }
@@ -13,9 +13,6 @@ export function isMediaLibraryAssetFunctionResource(r) {
 export function isScheduleFunctionResource(r) {
     return r.type === SANITY_FUNCTION_SCHEDULED;
 }
-export function isLocalFunctionCollection(r) {
-    return r.type === 'sanity.experimental.functions-collection';
-}
 export function isScheduleEvent(e) {
     return e !== null && typeof e === 'object' && ('hour' in e || 'expression' in e);
 }
@@ -34,6 +31,10 @@ export function isRoleResource(r) {
 export function isDatasetResource(r) {
     return validateDataset(r).length === 0;
 }
+// TODO: update to use blueprints helpers once available
+export function isStudioResource(r) {
+    return !!r && typeof r === 'object' && 'type' in r && r.type === 'sanity.studio';
+}
 export function isWebhookResource(r) {
     return validateDocumentWebhook(r).length === 0;
 }

package/dist/utils/validate/resource.d.ts

@@ -1,4 +1 @@
-import type { FunctionResource } from '../types.js';
-import { type BlueprintParserError } from '../types.js';
 export declare function validateFunctionName(name: string): boolean;
-export declare function validateFunctionResource(resource: FunctionResource): BlueprintParserError[];

package/dist/utils/validate/resource.js

@@ -1,274 +1,4 @@
-import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
-import { BlueprintParserErrorType, isDocumentFunctionResource, isMediaLibraryAssetFunctionResource, isScheduleEvent, } from '../types.js';
 export function validateFunctionName(name) {
     // must be 3+ characters, no special characters, no spaces, allow _ and -
     return /^[a-zA-Z0-9][a-zA-Z0-9_-]{2,}$/.test(name);
 }
-const validFunctionEventNames = ['publish', 'create', 'update', 'delete'];
-export function validateFunctionResource(resource) {
-    const { name: fnName } = resource;
-    const msgPrefix = `Function "${fnName}":`;
-    const errors = [];
-    if (!validateFunctionName(resource.name)) {
-        errors.push({
-            message: `${msgPrefix} Function name must be at least 3 characters, start with a letter or number, and only contain letters, numbers, _ or -`,
-            type: BlueprintParserErrorType.InvalidProperty,
-        });
-    }
-    if (!resource.type.startsWith(SANITY_FUNCTION_PREFIX)) {
-        errors.push({
-            message: `${msgPrefix} Resource type must start with "${SANITY_FUNCTION_PREFIX}"`,
-            type: BlueprintParserErrorType.InvalidType,
-        });
-    }
-    if (isScheduleEvent(resource.event)) {
-        const event = resource.event;
-        const hasExpression = 'expression' in event;
-        const hasExplicitFields = 'minute' in event ||
-            'hour' in event ||
-            'dayOfMonth' in event ||
-            'month' in event ||
-            'dayOfWeek' in event;
-        if (hasExpression && hasExplicitFields) {
-            errors.push({
-                type: BlueprintParserErrorType.InvalidFormat,
-                message: 'Cannot specify both `expression` and explicit cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`)',
-            });
-        }
-        else if (!hasExpression && !hasExplicitFields) {
-            errors.push({
-                type: BlueprintParserErrorType.MissingRequiredProperty,
-                message: 'Either `expression` or explicit cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`) must be provided',
-            });
-        }
-        else if (hasExpression) {
-            const expressionParts = event.expression.split(' ');
-            if (expressionParts.length !== 5) {
-                errors.push({
-                    type: BlueprintParserErrorType.InvalidFormat,
-                    message: 'Invalid `expression` format. Cron fields (`minute`, `hour`, `dayOfMonth`, `month`, `dayOfWeek`) must be provided',
-                });
-            }
-            else {
-                const [minute, hour, dayOfWeek, month, dayOfMonth] = expressionParts;
-                errors.push(...validateScheduleEvent(msgPrefix, { minute, hour, dayOfWeek, month, dayOfMonth }));
-            }
-        }
-        else if (hasExplicitFields) {
-            errors.push(...validateScheduleEvent(msgPrefix, event));
-        }
-    }
-    else {
-        if (!resource.event || !Array.isArray(resource.event.on) || resource.event.on.length === 0) {
-            errors.push({
-                message: `${msgPrefix} event.on must be a non-empty array`,
-                type: BlueprintParserErrorType.MissingRequiredProperty,
-            });
-        }
-        else if (!resource.event.on.every((evt) => validFunctionEventNames.includes(evt))) {
-            errors.push({
-                message: `${msgPrefix} event.on values must be one of ${validFunctionEventNames.map((e) => `"${e}"`).join(', ')}`,
-                type: BlueprintParserErrorType.InvalidValue,
-            });
-        }
-        if (resource.event?.filter && typeof resource.event.filter !== 'string') {
-            errors.push({
-                message: `${msgPrefix} event.filter must be a string`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        if (resource.event?.projection && typeof resource.event.projection !== 'string') {
-            errors.push({
-                message: `${msgPrefix} event.projection must be a string`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-    }
-    if (resource.memory !== undefined) {
-        if (!Number.isInteger(resource.memory)) {
-            errors.push({
-                message: `${msgPrefix} memory must be an integer`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        else if (resource.memory < 1 || resource.memory > 10) {
-            errors.push({
-                message: `${msgPrefix} memory must be between 1 and 10 (GB)`,
-                type: BlueprintParserErrorType.InvalidValue,
-            });
-        }
-    }
-    if (resource.timeout !== undefined) {
-        if (!Number.isInteger(resource.timeout)) {
-            errors.push({
-                message: `${msgPrefix} timeout must be an integer`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        else if (resource.timeout < 1 || resource.timeout > 900) {
-            errors.push({
-                message: `${msgPrefix} timeout must be between 1 and 900 (seconds)`,
-                type: BlueprintParserErrorType.InvalidValue,
-            });
-        }
-    }
-    if (resource.env !== undefined) {
-        if (typeof resource.env !== 'object') {
-            errors.push({
-                message: `${msgPrefix} env must be an object`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        else {
-            if (!Object.keys(resource.env).every((key) => typeof key === 'string')) {
-                errors.push({
-                    message: `${msgPrefix} All env keys must be strings`,
-                    type: BlueprintParserErrorType.InvalidFormat,
-                });
-            }
-            if (!Object.values(resource.env).every((value) => typeof value === 'string')) {
-                errors.push({
-                    message: `${msgPrefix} All env values must be strings`,
-                    type: BlueprintParserErrorType.InvalidFormat,
-                });
-            }
-        }
-    }
-    if (resource.event && 'resource' in resource.event && resource.event.resource) {
-        if (!resource.event.resource.type) {
-            errors.push({
-                message: `${msgPrefix} event.resource.type must be defined`,
-                type: BlueprintParserErrorType.MissingRequiredProperty,
-            });
-        }
-        if (!resource.event.resource.id) {
-            errors.push({
-                message: `${msgPrefix} event.resource.id must be defined`,
-                type: BlueprintParserErrorType.MissingRequiredProperty,
-            });
-        }
-    }
-    if (isMediaLibraryAssetFunctionResource(resource)) {
-        if (resource.event.resource.type !== 'media-library') {
-            errors.push({
-                message: `${msgPrefix} event.resource.type must be "media-library"`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-    }
-    if (isDocumentFunctionResource(resource) && resource.event) {
-        if (resource.event.includeDrafts && typeof resource.event.includeDrafts !== 'boolean') {
-            errors.push({
-                message: `${msgPrefix} event.includeDrafts must be a boolean`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        if (resource.event.includeAllVersions &&
-            typeof resource.event.includeAllVersions !== 'boolean') {
-            errors.push({
-                message: `${msgPrefix} event.includeAllVersions must be a boolean`,
-                type: BlueprintParserErrorType.InvalidType,
-            });
-        }
-        if (resource.event.resource) {
-            if (!resource.event.resource.type || resource.event.resource.type !== 'dataset') {
-                errors.push({
-                    message: `${msgPrefix} event.resource.type must be "dataset"`,
-                    type: BlueprintParserErrorType.InvalidType,
-                });
-            }
-            // Ensure exactly one period is passed into the ID to conform to the format <projectId>.<datasetName>
-            if (!resource.event.resource.id || resource.event.resource.id.split('.').length !== 2) {
-                errors.push({
-                    message: `${msgPrefix} event.resource.id must be of the form <projectId>.<datasetName>. <datasetName> can be "*" to signify "all datasets in project with ID <projectId>."`,
-                    type: BlueprintParserErrorType.InvalidFormat,
-                });
-            }
-            // TODO: validate the project ID and dataset names exist by making an API call?
-            // NB: this is done by the functions service
-        }
-    }
-    return errors;
-}
-function validateScheduleEvent(msgPrefix, event) {
-    const errors = [];
-    const properties = [
-        { name: 'minute', regex: MINUTES },
-        { name: 'hour', regex: HOURS },
-        { name: 'dayOfMonth', regex: DAY_OF_MONTH },
-        { name: 'month', regex: MONTH },
-        { name: 'dayOfWeek', regex: DAY_OF_WEEK },
-    ];
-    properties.forEach((prop) => {
-        const { name, regex } = prop;
-        if (!(name in event)) {
-            errors.push({
-                type: BlueprintParserErrorType.MissingRequiredProperty,
-                message: `${msgPrefix} '${name}' must be provided`,
-            });
-            return;
-        }
-        const value = event[name];
-        if (typeof value !== 'string') {
-            errors.push({
-                type: BlueprintParserErrorType.InvalidType,
-                message: `${msgPrefix} '${name}' must be a string`,
-            });
-            return;
-        }
-        if (!isValidCronPart(regex, value)) {
-            errors.push({
-                type: BlueprintParserErrorType.InvalidValue,
-                message: `${msgPrefix} ${name} field contains invalid value: ${value}`,
-            });
-        }
-    });
-    return errors;
-}
-/**
- * Validates that each cron part adheres to it's rules
- *
- * @param {RegExp} regex the regular expression that corresponds to the part of the cron expression you are testing
- * @param {string} value the string value of part of the cron expression you are testing
- * @returns {boolean} whether or not the cron part is valid
- */
-function isValidCronPart(regex, value) {
-    return regex.test(value) && checkAscendingRanges(value) && checkNoZeroStep(value);
-}
-const MINUTES = /^(\*(\/([1-5]?\d))?|([0-5]?\d)(-[0-5]?\d)?(\/([1-5]?\d))?)(,(\*(\/([1-5]?\d))?|([0-5]?\d)(-[0-5]?\d)?(\/([1-5]?\d))?))*$/;
-const HOURS = /^(\*(\/([1-9]|1\d|2[0-3]))?|([01]?\d|2[0-3])(-([01]?\d|2[0-3]))?(\/([1-9]|1\d|2[0-3]))?)(,(\*(\/([1-9]|1\d|2[0-3]))?|([01]?\d|2[0-3])(-([01]?\d|2[0-3]))?(\/([1-9]|1\d|2[0-3]))?))*$/;
-const DAY_OF_MONTH = /^(\*(\/([1-9]|[12]\d|3[01]))?|([1-9]|[12]\d|3[01])(-([1-9]|[12]\d|3[01]))?(\/([1-9]|[12]\d|3[01]))?)(,(\*(\/([1-9]|[12]\d|3[01]))?|([1-9]|[12]\d|3[01])(-([1-9]|[12]\d|3[01]))?(\/([1-9]|[12]\d|3[01]))?))*$/;
-const MONTH = /^(\*(\/([1-9]|1[0-2]))?|([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(-([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?(\/([1-9]|1[0-2]))?)(,(\*(\/([1-9]|1[0-2]))?|([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC)(-([1-9]|1[0-2]|JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC))?(\/([1-9]|1[0-2]))?))*$/i;
-const DAY_OF_WEEK = /^(\*(\/([0-7]))?|([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT)(-([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT))?(\/([0-7]))?)(,(\*(\/([0-7]))?|([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT)(-([0-7]|SUN|MON|TUE|WED|THU|FRI|SAT))?(\/([0-7]))?))*$/i;
-/**
- *
- * @param {string} value the string value of part of the cron expression you are testing
- * @returns {boolean} returns true if the range is valid
- */
-function checkAscendingRanges(value) {
-    for (const part of value.split(',')) {
-        if (part.includes('-')) {
-            const [start, right] = part.split('-');
-            const end = right.split('/')[0]; // remove /step
-            const s = Number(start);
-            const e = Number(end);
-            if (s > e)
-                return false;
-        }
-    }
-    return true;
-}
-/**
- * @param {string} value the string value of part of the cron expression you are testing
- * @returns {boolean} makes sure we are not trying to divide by zero
- */
-function checkNoZeroStep(value) {
-    for (const part of value.split(',')) {
-        if (part.includes('/')) {
-            const step = Number(part.split('/')[1]);
-            if (step === 0)
-                return false;
-        }
-    }
-    return true;
-}

package/dist/utils/validated-token.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from './logger.js';
 import type { Result } from './types.js';
-export declare function validToken(logger: ReturnType<typeof Logger>, maybeToken?: string): Promise<string>;
-export declare function validTokenOrErrorMessage(logger: ReturnType<typeof Logger>, maybeToken?: string): Promise<Result<string, {
+export declare function validToken(logger: Logger, maybeToken?: string): Promise<string>;
+export declare function validTokenOrErrorMessage(logger: Logger, maybeToken?: string): Promise<Result<string, {
     e: Error | unknown;
     message: string;
 }>>;