@sanity/runtime-cli 14.7.2 → 14.8.1

package/dist/utils/invoke-local.js

@@ -11,30 +11,13 @@ import { resolveResourceDependencies } from './functions/resolve-dependencies.js
 import { shouldAutoResolveDependencies } from './functions/should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './functions/should-transpile.js';
 import { transpileFunction } from './transpile/transpile-function.js';
-import { isDocumentFunctionResource, isGroqContextOptions, isMediaLibraryAssetFunctionResource, } from './types.js';
+import { isGroqContextOptions, } from './types.js';
 function getChildProcessWrapperPath() {
     return fileURLToPath(new URL('./child-process-wrapper.js', import.meta.url));
 }
 export function sanitizeLogs(logs) {
     return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
 }
-export const DEFAULT_GROQ_RULE = { on: ['publish'], filter: '', projection: '' };
-export function isDefaultGROQRule(rule) {
-    if (!rule)
-        return true;
-    return (Array.isArray(rule.on) &&
-        rule.on.length === DEFAULT_GROQ_RULE.on.length &&
-        rule.on.every((v) => DEFAULT_GROQ_RULE.on.includes(v)) &&
-        rule.filter === DEFAULT_GROQ_RULE.filter &&
-        rule.projection === DEFAULT_GROQ_RULE.projection);
-}
-function getEvent(rule) {
-    return {
-        on: rule.on || DEFAULT_GROQ_RULE.on,
-        filter: rule.filter || DEFAULT_GROQ_RULE.filter,
-        projection: rule.projection || DEFAULT_GROQ_RULE.projection,
-    };
-}
 export async function applyGroqRule(resource, payload, projectId, dataset) {
     const { before, after, payload: data = null } = payload;
     // If there is no rule set return everything
@@ -42,11 +25,8 @@ export async function applyGroqRule(resource, payload, projectId, dataset) {
         return data;
     // default groq rule is: gimme full doc content. otherwise, parse + eval custom rule
     // applying the GROQ filter may result in a slimmer set of documents
-    const event = getEvent(resource.event);
-    if (!isDefaultGROQRule(event)) {
-        const hasProjection = event.projection?.length;
-        const projection = hasProjection ? `${event?.projection}` : '';
-        const query = `*[${event?.filter}]${projection}`;
+    if (resource.event.filter || resource.event.projection) {
+        const query = `*[${resource.event.filter || ''}]${resource.event.projection || ''}`;
         try {
             const rule = groq.parse(query, { mode: 'delta' });
             const sanity = projectId && dataset ? { projectId, dataset } : undefined;
@@ -91,7 +71,8 @@ export default async function invoke(resource, payload, context, options) {
     }
     const { forceColor = true, timeout = 10 } = options;
     let filteredData = {};
-    if (isDocumentFunctionResource(resource) || isMediaLibraryAssetFunctionResource(resource)) {
+    if (resource.type === 'sanity.function.document' ||
+        resource.type === 'sanity.function.media-library.asset') {
         if (!isGroqContextOptions(context)) {
             throw new Error('GROQ-based functions require a context with clientOptions');
         }

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

@@ -1,6 +1,5 @@
-import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentWebhookResource, type BlueprintProjectResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource } from '@sanity/blueprints';
+import { type BlueprintCorsOriginResource, type BlueprintDatasetResource, type BlueprintDocumentFunctionResource, type BlueprintDocumentWebhookResource, type BlueprintMediaLibraryAssetFunctionResource, type BlueprintProjectResource, type BlueprintResource, type BlueprintRobotResource, type BlueprintRoleResource, type BlueprintScheduledFunctionResource } from '@sanity/blueprints';
 import type { Blueprint } from '@sanity/blueprints-parser';
-import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_SCHEDULED } from '../constants.js';
 export type ScopeType = 'organization' | 'project';
 /** Result utility type */
 export type Result<T, E = string> = {
@@ -10,6 +9,14 @@ 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 type FunctionGroqResource = BlueprintDocumentFunctionResource | BlueprintMediaLibraryAssetFunctionResource;
+export type FunctionResource = FunctionGroqResource | BlueprintScheduledFunctionResource;
 /** @internal */
 export interface AuthParams {
     token: string;
@@ -17,37 +24,6 @@ export interface AuthParams {
     scopeId: string;
 }
 /** @internal */
-export type GroqRule = GroqRuleDocumentFunction | GroqRuleMediaLibraryFunction;
-export interface GroqRuleBase {
-    on: Array<string>;
-    filter?: string;
-    projection?: string;
-}
-interface GroqRuleDocumentFunction extends GroqRuleBase {
-    includeDrafts?: boolean;
-    includeAllVersions?: boolean;
-    resource?: {
-        type: 'dataset';
-        id: string;
-    };
-}
-interface GroqRuleMediaLibraryFunction extends GroqRuleBase {
-    resource: {
-        type: 'media-library';
-        id: string;
-    };
-}
-export interface FunctionResourceScheduleExplicitEvent {
-    minute: string;
-    hour: string;
-    dayOfMonth: string;
-    month: string;
-    dayOfWeek: string;
-}
-interface FunctionResourceScheduleExpressionEvent {
-    expression: string;
-}
-type FunctionResourceScheduleEvent = FunctionResourceScheduleExplicitEvent | FunctionResourceScheduleExpressionEvent;
 /** The Blueprint resource as represented in the Blueprints API database */
 export interface BlueprintResourceRecord extends BlueprintResource {
     id: string;
@@ -58,60 +34,16 @@ export interface BlueprintResourceRecord extends BlueprintResource {
 export interface DeployedResource extends BlueprintResourceRecord {
     externalId: string;
 }
-export declare function isLocalFunctionResource(r: BlueprintResource): r is FunctionResourceBase;
-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 isLocalFunctionResource(r: BlueprintResource): r is FunctionResource;
+export declare function isScheduleEvent(e: unknown): e is BlueprintScheduledFunctionResource['event'];
 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;
-export type FunctionGroqResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset;
-export interface FunctionResourceBase extends BlueprintResource {
-    displayName?: string;
-    src?: string;
-    autoResolveDeps?: boolean;
-    transpile?: boolean;
-    memory?: number;
-    timeout?: number;
-    env?: Record<string, string>;
-    event?: GroqRuleBase | FunctionResourceScheduleEvent;
-}
-interface FunctionResourceDocument extends FunctionResourceBase {
-    type: typeof SANITY_FUNCTION_DOCUMENT;
-    event?: GroqRuleDocumentFunction;
-}
-interface FunctionResourceMediaLibraryAsset extends FunctionResourceBase {
-    type: typeof SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
-    event: GroqRuleMediaLibraryFunction;
-}
-interface FunctionResourceSchedule extends FunctionResourceBase {
-    type: typeof SANITY_FUNCTION_SCHEDULED;
-    event: FunctionResourceScheduleEvent;
-}
-export interface CollectionFunction {
-    type: typeof SANITY_FUNCTION_DOCUMENT | typeof SANITY_FUNCTION_SCHEDULED | typeof SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
-    src: string;
-    name: string;
-    displayName?: string;
-    event?: GroqRuleBase | FunctionResourceScheduleEvent;
-    memory?: number;
-    timeout?: number;
-    env?: Record<string, string>;
-}
-/** @internal */
-export interface FunctionsCollection extends BlueprintResource {
-    type: 'sanity.experimental.functions-collection';
-    name: string;
-    src?: string;
-    functions: Array<FunctionResourceBase>;
-}
 export interface CorsResource extends BlueprintResource {
     origin?: string;
 }
@@ -258,4 +190,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,21 +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
+import { SANITY_FUNCTION_PREFIX } from '../constants.js';
 export function isLocalFunctionResource(r) {
     return r.type.startsWith(SANITY_FUNCTION_PREFIX);
 }
-export function isDocumentFunctionResource(r) {
-    return r.type === SANITY_FUNCTION_DOCUMENT;
-}
-export function isMediaLibraryAssetFunctionResource(r) {
-    return r.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
-}
-export function isScheduleFunctionResource(r) {
-    return r.type === SANITY_FUNCTION_SCHEDULED;
-}
-export function isLocalFunctionCollection(r) {
-    return r.type === 'sanity.experimental.functions-collection';
-}
+// type narrowing with predicate functions
 export function isScheduleEvent(e) {
     return e !== null && typeof e === 'object' && ('hour' in e || 'expression' in e);
 }
@@ -34,6 +22,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;
 }>>;