forked from unom/punktfunk
enricobuehler
10a0ef3283
The kit had NO biome config and no lint script, while every plugin repo that
consumes it has both. So its source quietly drifted — unused imports, unsorted
imports, formatting — with nothing to catch any of it. Running biome here for
the first time reported 20 findings across 8 files.
Adds `plugin-kit/biome.json` mirroring the plugin repos' (tab indent, double
quotes, recommended lint preset, organizeImports), a `check` script, and
`@biomejs/biome` pinned to the same `^2.5.2` the plugins pin — without that pin
`bunx biome` resolved 2.4.6, which rejects the 2.5 `rules.preset` key.
Two deliberate differences from the plugin repos' copy:
* no `vcs.useIgnoreFile` — those are standalone repos with a .gitignore beside
the config; plugin-kit is a directory inside this one, and biome errors with
"couldn't find an ignore file". The `files.includes` exclusions cover it.
* `!examples/**/dist` instead of `!ui/dist` — the kit has examples, not a UI.
`css.parser.tailwindDirectives` is carried over and is load-bearing: without it
biome cannot parse `@theme` in src/theme.css and reports three parse errors on
CSS that is perfectly valid Tailwind v4.
Everything here is formatter/import churn except two real findings, both fixed:
* `Layer` (library/define.ts) and `Cause` (sync-engine.ts) were imported and
never used;
* test/spike-httpapi.test.ts read `(reg?.body as …).ui.secret` one line after
`expect(reg).toBeDefined()`. The optional chain undoes the assertion: had
`reg` been undefined the `.ui` access would throw a TypeError instead of
failing the test readably. Now asserted to the type system too.
Wired into plugin-kit-publish.yml as a `Lint & format` step ahead of Typecheck,
so this cannot rot again.
Gates after: biome clean (42 files), tsc clean, 67/67 tests, build clean.
63 lines
2.3 KiB
TypeScript
63 lines
2.3 KiB
TypeScript
// Disposable derived state (cache.json): corrupt or absent falls back to `empty` and
|
|
// never fails a read; every `modify` is write-through with the same atomic-write
|
|
// discipline as config. Held in a Ref so reads are cheap and mutations are ordered.
|
|
import * as fs from "node:fs";
|
|
import { Effect, Ref, Schema } from "effect";
|
|
import type { ConfigWriteError } from "./errors.js";
|
|
import { PluginInfo } from "./host-client.js";
|
|
import { atomicWriteFile, ensureStateDir, statePath } from "./paths.js";
|
|
|
|
export interface CacheStore<S extends Schema.Top> {
|
|
readonly get: Effect.Effect<S["Type"]>;
|
|
/** Atomically update the cache (Ref + write-through). Returns the `modify` result. */
|
|
readonly modify: <A>(
|
|
f: (current: S["Type"]) => readonly [A, S["Type"]],
|
|
) => Effect.Effect<A, ConfigWriteError>;
|
|
/** `modify` without a result. */
|
|
readonly update: (
|
|
f: (current: S["Type"]) => S["Type"],
|
|
) => Effect.Effect<void, ConfigWriteError>;
|
|
/** Absolute path of the cache file (status views). */
|
|
readonly path: string;
|
|
}
|
|
|
|
export const makeCacheStore = <S extends Schema.Top>(opts: {
|
|
readonly schema: S;
|
|
readonly empty: S["Type"];
|
|
readonly fileName?: string;
|
|
}): Effect.Effect<CacheStore<S>, never, PluginInfo> =>
|
|
Effect.gen(function* () {
|
|
const info = yield* PluginInfo;
|
|
const file = statePath(info.name, opts.fileName ?? "cache.json");
|
|
|
|
const initial = yield* Effect.suspend(() => {
|
|
try {
|
|
const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
|
|
return Schema.decodeUnknownEffect(opts.schema)(parsed).pipe(
|
|
Effect.orElseSucceed(() => opts.empty),
|
|
) as Effect.Effect<S["Type"]>;
|
|
} catch {
|
|
return Effect.succeed(opts.empty);
|
|
}
|
|
});
|
|
const ref = yield* Ref.make<S["Type"]>(initial);
|
|
|
|
const persist = (value: S["Type"]) =>
|
|
ensureStateDir(info.name).pipe(
|
|
Effect.flatMap(() => atomicWriteFile(file, JSON.stringify(value))),
|
|
);
|
|
|
|
const modify = <A>(f: (current: S["Type"]) => readonly [A, S["Type"]]) =>
|
|
Ref.modify(ref, (current) => {
|
|
const [a, next] = f(current);
|
|
return [[a, next] as const, next] as const;
|
|
}).pipe(Effect.flatMap(([a, next]) => persist(next).pipe(Effect.as(a))));
|
|
|
|
return {
|
|
get: Ref.get(ref),
|
|
modify,
|
|
update: (f) => modify((c) => [undefined, f(c)] as const),
|
|
path: file,
|
|
} satisfies CacheStore<S>;
|
|
});
|