@types/cacache

property integrity

integrity: string;

• Subresource Integrity hash for the content this entry refers to.

property key

key: string;

• Key the entry was looked up under. Matches the key argument.

property metadata

metadata?: any;

• User-assigned metadata associated with the entry/content.

property path

path: string;

• Filesystem path where content is stored, joined with cache argument.

property size

size?: number;

• Size of the data

property time

time: number;

• Timestamp the entry was first added on.

property data

data: Buffer;

property integrity

integrity: string;

property metadata

metadata?: any;

property size

size?: number;

property get

get: (key: string) => object | undefined;

property set

set: (key: string, value: object) => void;

function byDigest

byDigest: (cachePath: string, hash: string, opts?: Options) => Promise<Buffer>;

function copy

copy: typeof copy;

function hasContent

hasContent: (
    cachePath: string,
    hash: string
) => Promise<HasContentObject | false>;

• Looks up a Subresource Integrity hash in the cache. If content exists for this integrity, it will return an object, with the specific single integrity hash that was found in sri key, and the size of the found content as size. If no content exists for this integrity, it will return false.

function info

info: (cachePath: string, key: string) => Promise<CacheObject>;

• Looks up key in the cache index, returning information about the entry if one exists.

function stream

stream: typeof stream;

• Returns a Readable Stream of the cached data identified by key.

  If there is no content identified by key, or if the locally-stored data does not pass the validity checksum, an error will be emitted.

  metadata and integrity events will be emitted before the stream closes, if you need to collect that extra data about the cached entry.

  A sub-function, get.stream.byDigest may be used for identical behavior, except lookup will happen by integrity hash, bypassing the index entirely. This version does not emit the metadata and integrity events at all.

type CopyResultObject

type CopyResultObject = Pick<CacheObject, 'metadata' | 'integrity' | 'size'>;

function byDigest

byDigest: (
    cachePath: string,
    hash: string,
    dest: string,
    opts?: Options
) => Promise<string>;

function byDigest

byDigest: (
    cachePath: string,
    hash: string,
    opts?: Options
) => Minipass<Buffer, never>;

function compact

compact: (
    cache: string,
    key: string,
    matchFn: (obj1: CacheObject, obj2: CacheObject) => boolean,
    opts?: CompactOptions
) => Promise<CacheObject[]>;

• Uses matchFn, which must be a synchronous function that accepts two entries and returns a boolean indicating whether or not the two entries match, to deduplicate all entries in the cache for the given key.

  If opts.validateEntry is provided, it will be called as a function with the only parameter being a single index entry. The function must return a Boolean, if it returns true the entry is considered valid and will be kept in the index, if it returns false the entry will be removed from the index.

  If opts.validateEntry is not provided, however, every entry in the index will be deduplicated and kept until the first null integrity is reached, removing all entries that were written before the null.

  The deduplicated list of entries is both written to the index, replacing the existing content, and returned in the Promise.

function insert

insert: (
    cache: string,
    key: string,
    integrity: string,
    opts?: InsertOptions
) => Promise<CacheObject>;

• Writes an index entry to the cache for the given key without writing content.

  It is assumed if you are using this method, you have already stored the content some other way and you only wish to add a new index to that content. The metadata and size properties are read from opts and used as part of the index entry.

  Returns a Promise resolving to the newly added entry.

function stream

stream: (cachePath: string) => Minipass<Cache, never>;

• Lists info for all entries currently in the cache as a single large object.

  This works just like ls, except get.info entries are returned as 'data' events on the returned stream.

type Cache

type Cache = Record<string, CacheObject & { size: number }>;

function stream

stream: (
    cachePath: string,
    key: string,
    opts?: Options
) => Minipass<never, Minipass.ContiguousData, PutStreamEvents>;

• Returns a Writable Stream that inserts data written to it into the cache. Emits an integrity event with the digest of written contents when it succeeds.

function all

all: (cachePath: string) => Promise<void>;

• Clears the entire cache. Mainly by blowing away the cache directory itself.

function content

content: (cachePath: string, hash: string) => Promise<boolean>;

• Removes the content identified by integrity. Any index entries referring to it will not be usable again until the content is re-added to the cache with an identical digest.

function entry

entry: (cachePath: string, key: string) => Promise<CacheObject>;

• Removes the index entry for key. Content will still be accessible if requested directly by content address (get.stream.byDigest).

  To remove the content itself (which might still be used by other entries), use rm.content. Or, to safely vacuum any unused content, use verify.

function fix

fix: (cachePath: string) => Promise<void>;

• Sets the uid and gid properties on all files and folders within the tmp folder to match the rest of the cache.

  Use this after manually writing files into tmp.mkdir or tmp.withTmp.

function mkdir

mkdir: (cachePath: string, opts?: Options) => Promise<string>;

• Returns a unique temporary directory inside the cache's tmp dir. This directory will use the same safe user assignment that all the other stuff use.

  Once the directory is made, it's the user's responsibility that all files within are given the appropriate gid/uid ownership settings to match the rest of the cache. If not, you can ask cacache to do it for you by calling tmp.fix(), which will fix all tmp directory permissions.

  If you want automatic cleanup of this directory, use tmp.withTmp()

function withTmp

withTmp: {
    (cachePath: string, opts: Options, cb: Callback): void;
    (cachePath: string, cb: Callback): void;
};

• Creates a temporary directory with tmp.mkdir() and calls cb with it. The created temporary directory will be removed when the return value of cb() resolves, the tmp directory will be automatically deleted once that promise completes.

  The same caveats apply when it comes to managing permissions for the tmp dir's contents.

type Callback

type Callback = (dir: string) => void;

function lastRun

lastRun: (cachePath: string) => Promise<Date>;

• Returns a Date representing the last time cacache.verify was run on cache.