@sanity/cli-core 0.0.2-alpha.2 → 0.1.0-alpha.10

package/dist/config/util/recursivelyResolveProjectRoot.d.ts

@@ -1,27 +0,0 @@
-/**
- * Result of finding a project configuration
- *
- * @internal
- */
-export interface ProjectRootResult {
-    directory: string;
-    /**
-     * Path to the project configuration file, if found.
-     */
-    path: string;
-    /**
-     * Type of project root.
-     */
-    type: 'app' | 'studio';
-}
-/**
- * Generic recursive search function for project configuration files.
- *
- * @param basePath - The base path to start searching from
- * @param findConfigFn - Function that looks for config files in a given directory
- * @param projectType - The type of project ('app' | 'studio')
- * @param iterations - Current iteration count, passed internally to prevent infinite recursion
- * @returns A promise that resolves to an object if config is found, false otherwise
- * @internal
- */
-export declare function recursivelyResolveProjectRoot(basePath: string, findConfigFn: (path: string) => Promise<string | undefined>, projectType: 'app' | 'studio', iterations?: number): Promise<false | ProjectRootResult>;

package/dist/debug.d.ts

@@ -1,15 +0,0 @@
-import debugIt from 'debug';
-/**
- * `debug` instance for the CLI
- *
- * @internal
- */
-export declare const debug: debugIt.Debugger;
-/**
- * Get a `debug` instance which extends the CLI debug instance with the given namespace,
- * eg namespace would be `sanity:cli:<providedNamespace>`
- *
- * @param namespace - The namespace to extend the CLI debug instance with
- * @returns The extended `debug` instance
- */
-export declare const subdebug: (namespace: string) => debugIt.Debugger;

package/dist/loaders/studio/studioWorkerLoader.worker.d.ts

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

package/dist/loaders/studio/studioWorkerTask.d.ts

@@ -1,40 +0,0 @@
-import { type WorkerOptions } from 'node:worker_threads';
-import { type RequireProps } from '../../types.js';
-/**
- * Options for the studio worker task
- *
- * @internal
- */
-interface StudioWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {
-    studioRootPath: string;
-}
-/**
- * Executes a worker file in a Sanity Studio browser context.
- *
- * This uses a combination of vite for "bundling" + jsdom for emulating a browser
- * environment under the hood, which means that the same thing that will work in vite
- * _should_ work in the worker - to a degree. If the user has defined any typescript
- * path aliases, these will have to be added as aliases to the vite config - the same
- * behavior as you would see with regular vite. Other things that are accounted for:
- *
- * - TypeScript support (+JSX, enums and other "compilation needed" features)
- * - CSS, font and other file imports will resolve to a file path
- * - CSS module imports will resolve to a javascript object of class names
- * - Environment variables are available both as `import.meta.env` and `process.env`,
- *   and `.env` files are loaded in the same way that they would in a Sanity studio.
- * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
- *   are defined directly to the Node environment as globals. While this polutes the
- *   global namespace, it is done only in the worker thread.
- * - Certain browser globals that are _not_ available in JSDOM are also provided to the
- *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
- *   These are provided with a minimal stub implementation to make them not crash.
- *
- * @param filePath - Path to the worker file (`.ts` works and is encouraged)
- * @param options - Options to pass to the worker
- * @returns A promise that resolves with the message from the worker
- * @throws If the file does not exist
- * @throws If the worker exits with a non-zero code
- * @internal
- */
-export declare function studioWorkerTask(filePath: URL, options: StudioWorkerTaskOptions): Promise<unknown>;
-export {};

package/dist/loaders/tsx/tsxWorkerLoader.worker.d.ts

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

package/dist/loaders/tsx/tsxWorkerTask.d.ts

@@ -1,28 +0,0 @@
-import { URL } from 'node:url';
-import { type WorkerOptions } from 'node:worker_threads';
-import { type RequireProps } from '../../types.js';
-/**
- * Options for the tsx worker task
- *
- * @internal
- */
-interface TsxWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {
-    rootPath: string;
-}
-/**
- * Executes a worker file with tsx registered. This means you can import other
- * typescript with fairly rich syntax, and still have that only apply to the worker
- * thread instead of the full parent process. The worker should emit a message when
- * complete using `parentPort`. Once it has received a single message will resolve the
- * returned promise with that message. If you are expecting multiple messages, you will
- * have to implement another method ;)
- *
- * @param filePath - Path to the worker file
- * @param options - Options to pass to the worker
- * @returns A promise that resolves with the message from the worker
- * @throws If the file does not exist
- * @throws If the worker exits with a non-zero code
- * @internal
- */
-export declare function tsxWorkerTask<T = unknown>(filePath: URL, options: TsxWorkerTaskOptions): Promise<T>;
-export {};

package/dist/services/apiClient.d.ts

@@ -1,53 +0,0 @@
-import { type ClientConfig, type SanityClient } from '@sanity/client';
-/**
- * @internal
- */
-export interface GlobalCliClientOptions extends ClientConfig {
-    /**
-     * The API version to use for this client.
-     */
-    apiVersion: string;
-    /**
-     * Whether to require a user to be authenticated to use this client.
-     * Default: `false`.
-     * Throws an error if `true` and user is not authenticated.
-     */
-    requireUser?: boolean;
-}
-/**
- * Create a "global" (unscoped) Sanity API client.
- *
- * @param options - The options to use for the client.
- * @returns Promise that resolves to a configured Sanity API client.
- */
-export declare function getGlobalCliClient({ requireUser, ...config }: GlobalCliClientOptions): Promise<SanityClient>;
-/**
- * @internal
- */
-export interface ProjectCliClientOptions extends ClientConfig {
-    /**
-     * The API version to use for this client.
-     */
-    apiVersion: string;
-    /**
-     * The project ID to use for this client.
-     */
-    projectId: string;
-    /**
-     * The dataset to use for this client.
-     */
-    dataset?: string;
-    /**
-     * Whether to require a user to be authenticated to use this client.
-     * Default: `false`.
-     * Throws an error if `true` and user is not authenticated.
-     */
-    requireUser?: boolean;
-}
-/**
- * Create a "global" (unscoped) Sanity API client.
- *
- * @param options - The options to use for the client.
- * @returns Promise that resolves to a configured Sanity API client.
- */
-export declare function getProjectCliClient({ requireUser, ...config }: ProjectCliClientOptions): Promise<SanityClient>;

package/dist/services/cliUserConfig.d.ts

@@ -1,57 +0,0 @@
-import { z } from 'zod';
-declare const cliUserConfigSchema: {
-    authToken: z.ZodOptional<z.ZodString>;
-    telemetryConsent: z.ZodOptional<z.ZodObject<{
-        updatedAt: z.ZodOptional<z.ZodNumber>;
-        value: z.ZodObject<{
-            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
-            type: z.ZodString;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
-            type: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
-            type: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">>;
-    }, "strip", z.ZodTypeAny, {
-        value: {
-            type: string;
-            status: "undetermined" | "unset" | "granted" | "denied";
-        } & {
-            [k: string]: unknown;
-        };
-        updatedAt?: number | undefined;
-    }, {
-        value: {
-            type: string;
-            status: "undetermined" | "unset" | "granted" | "denied";
-        } & {
-            [k: string]: unknown;
-        };
-        updatedAt?: number | undefined;
-    }>>;
-};
-/**
- * The CLI user configuration schema.
- *
- * @internal
- */
-type CliUserConfig = z.infer<z.ZodObject<typeof cliUserConfigSchema>>;
-/**
- * Set the config value for the given property.
- * Validates that the passed value adheres to the defined CLI config schema.
- *
- * @param prop - The property to set the value for
- * @param value - The value to set
- * @internal
- */
-export declare function setConfig<P extends keyof CliUserConfig>(prop: P, value: CliUserConfig[P]): Promise<void>;
-/**
- * Get the config value for the given property
- *
- * @param prop - The property to get the value for
- * @returns The value of the given property
- * @internal
- */
-export declare function getConfig<P extends keyof CliUserConfig>(prop: P): Promise<CliUserConfig[P]>;
-export {};

package/dist/services/getCliToken.d.ts

@@ -1,7 +0,0 @@
-/**
- * Get the CLI authentication token from the environment or the config file
- *
- * @returns A promise that resolves to a CLI token, or undefined if no token is found
- * @internal
- */
-export declare function getCliToken(): Promise<string | undefined>;

package/dist/types.d.ts

@@ -1,7 +0,0 @@
-import { type Command } from '@oclif/core';
-export interface Output {
-    error: Command['error'];
-    log: Command['log'];
-    warn: Command['warn'];
-}
-export type RequireProps<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

package/dist/util/NotFoundError.d.ts

@@ -1,20 +0,0 @@
-/**
- * Error thrown when a file or directory is not found
- *
- * `code` is always `ENOENT` to mirror Node.js behavior when a file is not found
- *
- * @internal
- */
-export declare class NotFoundError extends Error {
-    code: string;
-    path?: string;
-    constructor(message: string, path?: string);
-}
-/**
- * Returns whether or not the given error is a `NotFoundError`
- *
- * @param err - The error to check
- * @returns `true` if the error is a `NotFoundError`, `false` otherwise
- * @internal
- */
-export declare function isNotFoundError(err: unknown): err is NotFoundError;

package/dist/util/__tests__/createExpiringConfig.test.js

@@ -1,400 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { createExpiringConfig } from '../createExpiringConfig.js';
-describe('createExpiringConfig', ()=>{
-    let mockStore;
-    let fetchValue;
-    let onCacheHit;
-    let onFetch;
-    let onRevalidate;
-    beforeEach(()=>{
-        // Mock ConfigStore
-        mockStore = {
-            delete: vi.fn(),
-            get: vi.fn(),
-            set: vi.fn()
-        };
-        // Reset all mocks
-        fetchValue = vi.fn();
-        onCacheHit = vi.fn();
-        onFetch = vi.fn();
-        onRevalidate = vi.fn();
-    });
-    test('returns fetched value when cache is empty', async ()=>{
-        const testValue = 'test-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(testValue),
-            key: 'test-key',
-            onCacheHit,
-            onFetch,
-            onRevalidate,
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        const result = await config.get();
-        expect(result).toBe(testValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-        expect(onCacheHit).not.toHaveBeenCalled();
-        expect(onRevalidate).not.toHaveBeenCalled();
-        expect(mockStore.set).toHaveBeenCalledWith('test-key', {
-            updatedAt: expect.any(Number),
-            value: testValue
-        });
-    });
-    test('returns cached value when it has not expired', async ()=>{
-        const cachedValue = 'cached-value';
-        const ttl = 5000;
-        const updatedAt = Date.now() - 1000 // 1 second ago (not expired)
-        ;
-        const config = createExpiringConfig({
-            fetchValue,
-            key: 'test-key',
-            onCacheHit,
-            onFetch,
-            onRevalidate,
-            store: mockStore,
-            ttl
-        });
-        // Mock cached value that hasn't expired
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt,
-            value: cachedValue
-        });
-        const result = await config.get();
-        expect(result).toBe(cachedValue);
-        expect(fetchValue).not.toHaveBeenCalled();
-        expect(onCacheHit).toHaveBeenCalledOnce();
-        expect(onFetch).not.toHaveBeenCalled();
-        expect(onRevalidate).not.toHaveBeenCalled();
-        expect(mockStore.set).not.toHaveBeenCalled();
-    });
-    test('fetches new value when cached value has expired', async ()=>{
-        const newValue = 'new-value';
-        const ttl = 1000;
-        const updatedAt = Date.now() - 2000 // 2 seconds ago (expired)
-        ;
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(newValue),
-            key: 'test-key',
-            onCacheHit,
-            onFetch,
-            onRevalidate,
-            store: mockStore,
-            ttl
-        });
-        // Mock expired cached value
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt,
-            value: 'old-value'
-        });
-        const result = await config.get();
-        expect(result).toBe(newValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onRevalidate).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-        expect(onCacheHit).not.toHaveBeenCalled();
-        expect(mockStore.set).toHaveBeenCalledWith('test-key', {
-            updatedAt: expect.any(Number),
-            value: newValue
-        });
-    });
-    test('deletes cached value from store', ()=>{
-        const config = createExpiringConfig({
-            fetchValue,
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        config.delete();
-        expect(mockStore.delete).toHaveBeenCalledWith('test-key');
-    });
-    test('handles concurrent get() calls correctly', async ()=>{
-        const testValue = 'test-value';
-        let resolvePromise;
-        const delayedFetch = new Promise((resolve)=>{
-            resolvePromise = resolve;
-        });
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockReturnValue(delayedFetch),
-            key: 'test-key',
-            onFetch,
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        // Start multiple concurrent get() calls
-        const promise1 = config.get();
-        const promise2 = config.get();
-        const promise3 = config.get();
-        // Resolve the fetch
-        resolvePromise(testValue);
-        const [result1, result2, result3] = await Promise.all([
-            promise1,
-            promise2,
-            promise3
-        ]);
-        expect(result1).toBe(testValue);
-        expect(result2).toBe(testValue);
-        expect(result3).toBe(testValue);
-        expect(fetchValue).toHaveBeenCalledOnce(); // Only one fetch should happen
-        expect(onFetch).toHaveBeenCalledOnce();
-    });
-    test('handles synchronous fetchValue function', async ()=>{
-        const testValue = 'sync-value';
-        const syncFetchValue = vi.fn().mockReturnValue(testValue);
-        const config = createExpiringConfig({
-            fetchValue: syncFetchValue,
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        const result = await config.get();
-        expect(result).toBe(testValue);
-        expect(syncFetchValue).toHaveBeenCalledOnce();
-    });
-    test('handles fetchValue throwing an error', async ()=>{
-        const error = new Error('Fetch failed');
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockRejectedValue(error),
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        await expect(config.get()).rejects.toThrow('Fetch failed');
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(mockStore.set).not.toHaveBeenCalled();
-    });
-    test('handles different data types as cached values', async ()=>{
-        const objectValue = {
-            key: 'value',
-            number: 42
-        };
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(objectValue),
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        const result = await config.get();
-        expect(result).toEqual(objectValue);
-        expect(mockStore.set).toHaveBeenCalledWith('test-key', {
-            updatedAt: expect.any(Number),
-            value: objectValue
-        });
-    });
-    test('works with TTL of 0 (immediate expiration)', async ()=>{
-        const testValue = 'test-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(testValue),
-            key: 'test-key',
-            onRevalidate,
-            store: mockStore,
-            ttl: 0
-        });
-        // Mock cached value that would be immediately expired
-        // Use a timestamp from 1ms ago to ensure it's > ttl (0)
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt: Date.now() - 1,
-            value: 'old-value'
-        });
-        const result = await config.get();
-        expect(result).toBe(testValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onRevalidate).toHaveBeenCalledOnce();
-    });
-    test('works without optional callback functions', async ()=>{
-        const testValue = 'test-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(testValue),
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        const result = await config.get();
-        expect(result).toBe(testValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-    });
-    test('handles cached value without updatedAt timestamp', async ()=>{
-        const newValue = 'new-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(newValue),
-            key: 'test-key',
-            onFetch,
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock cached value without updatedAt (invalid cache entry)
-        vi.mocked(mockStore.get).mockReturnValue({
-            value: 'old-value'
-        });
-        const result = await config.get();
-        expect(result).toBe(newValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-    });
-    test('handles cached value without value property', async ()=>{
-        const newValue = 'new-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(newValue),
-            key: 'test-key',
-            onFetch,
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock cached entry without value property
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt: Date.now()
-        });
-        const result = await config.get();
-        expect(result).toBe(newValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-    });
-    test('stores timestamp correctly when caching new values', async ()=>{
-        const testValue = 'test-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(testValue),
-            key: 'test-key',
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        await config.get();
-        expect(mockStore.set).toHaveBeenCalledWith('test-key', {
-            updatedAt: expect.any(Number),
-            value: testValue
-        });
-    });
-    test('subsequent requests after cache is populated use cached value', async ()=>{
-        const testValue = 'test-value';
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(testValue),
-            key: 'test-key',
-            onCacheHit,
-            onFetch,
-            store: mockStore,
-            ttl: 5000
-        });
-        // Mock empty cache for first request
-        vi.mocked(mockStore.get).mockReturnValueOnce(undefined);
-        // First request should fetch
-        const result1 = await config.get();
-        // Mock cache populated for subsequent request
-        vi.mocked(mockStore.get).mockReturnValueOnce({
-            updatedAt: Date.now(),
-            value: testValue
-        });
-        // Second request should hit cache
-        const result2 = await config.get();
-        expect(result1).toBe(testValue);
-        expect(result2).toBe(testValue);
-        expect(fetchValue).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-        expect(onCacheHit).toHaveBeenCalledOnce();
-    });
-    test('throws when cached value fails validateValue', async ()=>{
-        const invalidCached = 123;
-        const ttl = 10_000;
-        const validateValue = vi.fn((v)=>typeof v === 'string');
-        const config = createExpiringConfig({
-            fetchValue,
-            key: 'test-key',
-            onCacheHit,
-            onFetch,
-            onRevalidate,
-            store: mockStore,
-            ttl,
-            // @ts-expect-error vitest mocks don't jive with assertions
-            validateValue
-        });
-        // Cached entry that is not expired but invalid per validateValue
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt: Date.now(),
-            value: invalidCached
-        });
-        await expect(config.get()).rejects.toThrow('Stored value is invalid');
-        expect(validateValue).toHaveBeenCalledOnce();
-        expect(onCacheHit).not.toHaveBeenCalled();
-        expect(onFetch).not.toHaveBeenCalled();
-        expect(onRevalidate).not.toHaveBeenCalled();
-        expect(mockStore.set).not.toHaveBeenCalled();
-    });
-    test('throws when fetched value fails validateValue (cache miss)', async ()=>{
-        const validateValue = vi.fn((v)=>typeof v === 'string');
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(42),
-            key: 'test-key',
-            onFetch,
-            store: mockStore,
-            ttl: 5000,
-            // @ts-expect-error vitest mocks don't jive with assertions
-            validateValue
-        });
-        // Empty cache
-        vi.mocked(mockStore.get).mockReturnValue(undefined);
-        await expect(config.get()).rejects.toThrow('Fetched value is invalid');
-        expect(onFetch).toHaveBeenCalledOnce();
-        expect(validateValue).toHaveBeenCalledOnce();
-        expect(mockStore.set).not.toHaveBeenCalled();
-    });
-    test('returns cached value when validateValue accepts it', async ()=>{
-        const cachedValue = 'ok';
-        const validateValue = vi.fn((v)=>typeof v === 'string');
-        const config = createExpiringConfig({
-            fetchValue,
-            key: 'test-key',
-            onCacheHit,
-            store: mockStore,
-            ttl: 5000,
-            // @ts-expect-error vitest mocks don't jive with assertions
-            validateValue
-        });
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt: Date.now(),
-            value: cachedValue
-        });
-        const result = await config.get();
-        expect(result).toBe(cachedValue);
-        expect(validateValue).toHaveBeenCalledOnce();
-        expect(onCacheHit).toHaveBeenCalledOnce();
-        expect(fetchValue).not.toHaveBeenCalled();
-    });
-    test('revalidation path validates fetched value and throws if invalid', async ()=>{
-        const validateValue = vi.fn((v)=>typeof v === 'string');
-        const config = createExpiringConfig({
-            fetchValue: fetchValue.mockResolvedValue(99),
-            key: 'test-key',
-            onFetch,
-            onRevalidate,
-            store: mockStore,
-            ttl: 1,
-            // @ts-expect-error vitest mocks don't jive with assertions
-            validateValue
-        });
-        // Cached value that has expired but is otherwise valid in shape and passes validate
-        vi.mocked(mockStore.get).mockReturnValue({
-            updatedAt: Date.now() - 10,
-            value: 'stale'
-        });
-        await expect(config.get()).rejects.toThrow('Fetched value is invalid');
-        expect(onRevalidate).toHaveBeenCalledOnce();
-        expect(onFetch).toHaveBeenCalledOnce();
-        // validateValue called for stored value and fetched value
-        expect(validateValue).toHaveBeenCalledTimes(2);
-        expect(mockStore.set).not.toHaveBeenCalled();
-    });
-});
-
-//# sourceMappingURL=createExpiringConfig.test.js.map