@yolk-sdk/emulators 0.1.0-canary.96

package/dist/dropbox.mjs

@@ -0,0 +1,124 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, checkBooleanDrills, makeStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { DropboxEmulatorDeleted, DropboxEmulatorEntry, DropboxEmulatorEntrySeed, DropboxEmulatorFile, DropboxEmulatorProfile, DropboxEmulatorSeed, DropboxEmulatorStateSchema, buildSeedState, decodeState } from "./dropbox/state.mjs";
+import { dropboxApiRoutes, dropboxEmulatorApiOrigin, dropboxEmulatorBasePath, dropboxEmulatorContentOrigin, dropboxEmulatorDrillKnobs, dropboxEmulatorErrorBodies } from "./dropbox/api.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { Data, Predicate } from "effect";
+//#region src/dropbox.ts
+/**
+* Stateful Dropbox emulator (the `/2` RPC routes on `https://api.dropboxapi.com` and the upload
+* route on `https://content.dropboxapi.com`), built on the upstream `@emulators/core` custom
+* runtime, with a request ledger, status faults, and an `/_emulate/*` control plane.
+*
+* It never imports SDK code: its wire shapes, error envelopes, and default seed are copied as data
+* from the synthetic Dropbox conformance fixtures, and every route names the conformance cases it
+* follows in `dropboxEmulatorRoutes`. Only the routes those eight cases (with their cleanup) send
+* are emulated, each on the origin its fixtures record. Response behaviour comes only from the
+* fixtures: anything they do not show answers one ledgered 400 not-emulated, writes nothing, and
+* uses up no fault. That includes a listing of an empty folder, so the read-only leftover lookup
+* fails against the default seed's empty work folder (the live runner prints its lookup-failed
+* WARN).
+*
+* Request-shape latitude (`/dropbox`, the only accepted deviations): any bearer value (never
+* checked or stored); extra request headers; JSON key order; `content-type` media-type
+* parameters; any path and search query (looked up in the state); any `list_folder` `limit` from
+* 1 to 2000 and any `search_v2` `options.max_results` from 1 to 1000; and any upload body bytes.
+* Everything else (other keys, booleans, modes, query parameters, another origin, ids or revs
+* where the fixtures send paths, the root folder, and cursors not issued since the last reset or
+* whose listing changed) is not emulated.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeDropboxEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+/**
+* Route evidence manifest: every emulated route, whether it writes, and the conformance cases
+* whose (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers
+* by construction (both come from one route table).
+*/
+const dropboxEmulatorRoutes = dropboxApiRoutes.map(routeEvidence);
+/**
+* Optional fault filter; an omitted field matches every request. `method` is the HTTP method;
+* `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the
+* manifest (another value is rejected when the fault is added).
+*/
+const DropboxFaultMatch = StatefulFaultMatch;
+/**
+* A status fault (400-599): answer matching requests with this status, headers, and body instead
+* of the route's write, so nothing is written. The body defaults to
+* `{ error: { type: 'emulator_fault', message } }`; `count` limits how many requests it answers.
+* Only a request the emulator would answer reaches a fault: a request that is not emulated, by
+* its shape or by the state, never uses one up.
+*/
+const DropboxFault = StatefulFault;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+var DropboxEmulatorInputInvalid = class extends Data.TaggedError("DropboxEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Dropbox emulator ${this.input}: ${this.reason}`;
+	}
+};
+const inputInvalid = (input, reason) => new DropboxEmulatorInputInvalid({
+	input,
+	reason
+});
+/**
+* Create a stateful Dropbox emulator on the `@emulators/core` custom runtime. Each call has its
+* own state, ledger, faults, and cursors. Rejects with `DropboxEmulatorInputInvalid` for an
+* invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.
+*/
+const makeDropboxEmulator = async (options = {}) => {
+	const initial = buildSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw inputInvalid("seed", initial);
+	checkBooleanDrills(options.drills, dropboxEmulatorDrillKnobs, inputInvalid);
+	const drills = options.drills ?? {};
+	const env = {
+		now: options.now ?? (() => Date.now()),
+		drills: {
+			listFolderSinglePage: drills.listFolderSinglePage === true,
+			getMetadataCaseSensitive: drills.getMetadataCaseSensitive === true,
+			searchRepeatsMatches: drills.searchRepeatsMatches === true,
+			notFoundAsPathLookup: drills.notFoundAsPathLookup === true,
+			folderConflictAsFile: drills.folderConflictAsFile === true,
+			deleteLeavesNoTombstone: drills.deleteLeavesNoTombstone === true,
+			moveMintsNewId: drills.moveMintsNewId === true,
+			uploadIgnoresRev: drills.uploadIgnoresRev === true
+		},
+		cursors: /* @__PURE__ */ new Map(),
+		cursorCounters: {
+			list: 1,
+			search: 1
+		}
+	};
+	const cursors = () => [...env.cursors].map(([cursor, state]) => ({
+		cursor,
+		kind: state.kind,
+		offset: state.offset
+	}));
+	return {
+		...await makeStatefulEmulator({
+			routes: dropboxApiRoutes,
+			env,
+			initial,
+			buildSeed: buildSeedState,
+			recordHeaders: [{
+				name: "dropbox-api-arg",
+				json: true
+			}],
+			clearRuntime: () => env.cursors.clear(),
+			runtimeState: () => ({ cursors: cursors() }),
+			seedSummary: (state) => ({ entries: state.entries.length }),
+			inputInvalid
+		}, statefulCoreRuntime({
+			name: "dropbox",
+			initial,
+			decodeState,
+			inputInvalid
+		})),
+		cursors
+	};
+};
+//#endregion
+export { DropboxEmulatorDeleted, DropboxEmulatorEntry, DropboxEmulatorEntrySeed, DropboxEmulatorFile, DropboxEmulatorInputInvalid, DropboxEmulatorProfile, DropboxEmulatorSeed, DropboxEmulatorStateSchema, DropboxFault, DropboxFaultMatch, dropboxEmulatorApiOrigin, dropboxEmulatorBasePath, dropboxEmulatorContentOrigin, dropboxEmulatorErrorBodies, dropboxEmulatorRoutes, emulatorEvidenceHeader, makeDropboxEmulator };
+
+//# sourceMappingURL=dropbox.mjs.map

package/dist/dropbox.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropbox.mjs","names":[],"sources":["../src/dropbox.ts"],"sourcesContent":["/**\n * Stateful Dropbox emulator (the `/2` RPC routes on `https://api.dropboxapi.com` and the upload\n * route on `https://content.dropboxapi.com`), built on the upstream `@emulators/core` custom\n * runtime, with a request ledger, status faults, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes, error envelopes, and default seed are copied as data\n * from the synthetic Dropbox conformance fixtures, and every route names the conformance cases it\n * follows in `dropboxEmulatorRoutes`. Only the routes those eight cases (with their cleanup) send\n * are emulated, each on the origin its fixtures record. Response behaviour comes only from the\n * fixtures: anything they do not show answers one ledgered 400 not-emulated, writes nothing, and\n * uses up no fault. That includes a listing of an empty folder, so the read-only leftover lookup\n * fails against the default seed's empty work folder (the live runner prints its lookup-failed\n * WARN).\n *\n * Request-shape latitude (`/dropbox`, the only accepted deviations): any bearer value (never\n * checked or stored); extra request headers; JSON key order; `content-type` media-type\n * parameters; any path and search query (looked up in the state); any `list_folder` `limit` from\n * 1 to 2000 and any `search_v2` `options.max_results` from 1 to 1000; and any upload body bytes.\n * Everything else (other keys, booleans, modes, query parameters, another origin, ids or revs\n * where the fixtures send paths, the root folder, and cursors not issued since the last reset or\n * whose listing changed) is not emulated.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeDropboxEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport {\n  dropboxApiRoutes,\n  dropboxEmulatorDrillKnobs,\n  type DropboxApiEnv,\n  type DropboxCursor,\n  type DropboxEmulatorDrills\n} from './dropbox/api.ts'\nimport {\n  buildSeedState,\n  decodeState,\n  type DropboxEmulatorSeed,\n  type DropboxEmulatorState\n} from './dropbox/state.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport {\n  StatefulFault,\n  StatefulFaultMatch,\n  checkBooleanDrills,\n  makeStatefulEmulator,\n  routeEvidence,\n  type StatefulCoverage,\n  type StatefulEmulatorApi,\n  type StatefulFaultState,\n  type StatefulInputKind,\n  type StatefulLedgerEntry\n} from './stateful-emulator.ts'\nimport { statefulCoreRuntime } from './stateful-core.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport {\n  dropboxEmulatorApiOrigin,\n  dropboxEmulatorBasePath,\n  dropboxEmulatorContentOrigin,\n  dropboxEmulatorErrorBodies,\n  type DropboxEmulatorDrills\n} from './dropbox/api.ts'\n\nexport {\n  DropboxEmulatorDeleted,\n  DropboxEmulatorEntry,\n  DropboxEmulatorEntrySeed,\n  DropboxEmulatorFile,\n  DropboxEmulatorProfile,\n  DropboxEmulatorSeed,\n  DropboxEmulatorStateSchema,\n  type DropboxEmulatorState\n} from './dropbox/state.ts'\n\n/**\n * Route evidence manifest: every emulated route, whether it writes, and the conformance cases\n * whose (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers\n * by construction (both come from one route table).\n */\nexport const dropboxEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> =\n  dropboxApiRoutes.map(routeEvidence)\n\n/**\n * Optional fault filter; an omitted field matches every request. `method` is the HTTP method;\n * `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the\n * manifest (another value is rejected when the fault is added).\n */\nexport const DropboxFaultMatch = StatefulFaultMatch\n\nexport type DropboxFaultMatch = typeof StatefulFaultMatch.Type\n\n/**\n * A status fault (400-599): answer matching requests with this status, headers, and body instead\n * of the route's write, so nothing is written. The body defaults to\n * `{ error: { type: 'emulator_fault', message } }`; `count` limits how many requests it answers.\n * Only a request the emulator would answer reaches a fault: a request that is not emulated, by\n * its shape or by the state, never uses one up.\n */\nexport const DropboxFault = StatefulFault\n\nexport type DropboxFault = StatefulFault\n\nexport type DropboxFaultState = StatefulFaultState\n\nexport type DropboxLedgerEntry = StatefulLedgerEntry\n\nexport type DropboxCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */\nexport class DropboxEmulatorInputInvalid extends Data.TaggedError('DropboxEmulatorInputInvalid')<{\n  readonly input: StatefulInputKind\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Dropbox emulator ${this.input}: ${this.reason}`\n  }\n}\n\n/** A cursor as reported by `cursors()` and `/_emulate/state`. */\nexport type DropboxCursorState = {\n  readonly cursor: string\n  readonly kind: DropboxCursor['kind']\n  /** Position of the next page in the listing or search. */\n  readonly offset: number\n}\n\nexport type DropboxEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entries (`profile: 'default'`). */\n  readonly seed?: DropboxEmulatorSeed\n  /** Clock in epoch milliseconds (upload timestamps). Defaults to `Date.now`. */\n  readonly now?: () => number\n  /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */\n  readonly drills?: DropboxEmulatorDrills\n}\n\nexport type DropboxEmulator = StatefulEmulatorApi<DropboxEmulatorState, DropboxEmulatorSeed> & {\n  /** The list and search cursors issued since the last reset or seed (runtime data). */\n  readonly cursors: () => ReadonlyArray<DropboxCursorState>\n}\n\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new DropboxEmulatorInputInvalid({ input, reason })\n\n/**\n * Create a stateful Dropbox emulator on the `@emulators/core` custom runtime. Each call has its\n * own state, ledger, faults, and cursors. Rejects with `DropboxEmulatorInputInvalid` for an\n * invalid seed or option. See `src/stateful-emulator.ts` for the request precedence.\n */\nexport const makeDropboxEmulator = async (\n  options: DropboxEmulatorOptions = {}\n): Promise<DropboxEmulator> => {\n  const initial = buildSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw inputInvalid('seed', initial)\n  }\n\n  checkBooleanDrills(options.drills, dropboxEmulatorDrillKnobs, inputInvalid)\n\n  const drills = options.drills ?? {}\n\n  const env: DropboxApiEnv = {\n    now: options.now ?? (() => Date.now()),\n    drills: {\n      listFolderSinglePage: drills.listFolderSinglePage === true,\n      getMetadataCaseSensitive: drills.getMetadataCaseSensitive === true,\n      searchRepeatsMatches: drills.searchRepeatsMatches === true,\n      notFoundAsPathLookup: drills.notFoundAsPathLookup === true,\n      folderConflictAsFile: drills.folderConflictAsFile === true,\n      deleteLeavesNoTombstone: drills.deleteLeavesNoTombstone === true,\n      moveMintsNewId: drills.moveMintsNewId === true,\n      uploadIgnoresRev: drills.uploadIgnoresRev === true\n    },\n    cursors: new Map(),\n    cursorCounters: { list: 1, search: 1 }\n  }\n\n  const cursors = (): ReadonlyArray<DropboxCursorState> =>\n    [...env.cursors].map(([cursor, state]) => ({ cursor, kind: state.kind, offset: state.offset }))\n\n  const api = await makeStatefulEmulator<DropboxEmulatorState, DropboxApiEnv, DropboxEmulatorSeed>(\n    {\n      routes: dropboxApiRoutes,\n      env,\n      initial,\n      buildSeed: buildSeedState,\n      recordHeaders: [{ name: 'dropbox-api-arg', json: true }],\n      // Cursor numbers keep advancing, so a cursor issued before a reset is never issued again.\n      clearRuntime: () => env.cursors.clear(),\n      runtimeState: () => ({ cursors: cursors() }),\n      seedSummary: state => ({ entries: state.entries.length }),\n      inputInvalid\n    },\n    statefulCoreRuntime({ name: 'dropbox', initial, decodeState, inputInvalid })\n  )\n\n  return { ...api, cursors }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,MAAa,wBACX,iBAAiB,IAAI,aAAa;;;;;;AAOpC,MAAa,oBAAoB;;;;;;;;AAWjC,MAAa,eAAe;;AAW5B,IAAa,8BAAb,cAAiD,KAAK,YAAY,6BAA6B,EAG5F;CACD,IAAa,UAAkB;EAC7B,OAAO,4BAA4B,KAAK,MAAM,IAAI,KAAK;CACzD;AACF;AAwBA,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,4BAA4B;CAAE;CAAO;AAAO,CAAC;;;;;;AAOnD,MAAa,sBAAsB,OACjC,UAAkC,CAAC,MACN;CAC7B,MAAM,UAAU,eAAe,QAAQ,QAAQ,CAAC,CAAC;CAEjD,IAAI,UAAU,SAAS,OAAO,GAC5B,MAAM,aAAa,QAAQ,OAAO;CAGpC,mBAAmB,QAAQ,QAAQ,2BAA2B,YAAY;CAE1E,MAAM,SAAS,QAAQ,UAAU,CAAC;CAElC,MAAM,MAAqB;EACzB,KAAK,QAAQ,cAAc,KAAK,IAAI;EACpC,QAAQ;GACN,sBAAsB,OAAO,yBAAyB;GACtD,0BAA0B,OAAO,6BAA6B;GAC9D,sBAAsB,OAAO,yBAAyB;GACtD,sBAAsB,OAAO,yBAAyB;GACtD,sBAAsB,OAAO,yBAAyB;GACtD,yBAAyB,OAAO,4BAA4B;GAC5D,gBAAgB,OAAO,mBAAmB;GAC1C,kBAAkB,OAAO,qBAAqB;EAChD;EACA,yBAAS,IAAI,IAAI;EACjB,gBAAgB;GAAE,MAAM;GAAG,QAAQ;EAAE;CACvC;CAEA,MAAM,gBACJ,CAAC,GAAG,IAAI,OAAO,EAAE,KAAK,CAAC,QAAQ,YAAY;EAAE;EAAQ,MAAM,MAAM;EAAM,QAAQ,MAAM;CAAO,EAAE;CAkBhG,OAAO;EAAE,GAAG,MAhBM,qBAChB;GACE,QAAQ;GACR;GACA;GACA,WAAW;GACX,eAAe,CAAC;IAAE,MAAM;IAAmB,MAAM;GAAK,CAAC;GAEvD,oBAAoB,IAAI,QAAQ,MAAM;GACtC,qBAAqB,EAAE,SAAS,QAAQ,EAAE;GAC1C,cAAa,WAAU,EAAE,SAAS,MAAM,QAAQ,OAAO;GACvD;EACF,GACA,oBAAoB;GAAE,MAAM;GAAW;GAAS;GAAa;EAAa,CAAC,CAC7E;EAEiB;CAAQ;AAC3B"}

package/dist/email-fixtures.d.mts

@@ -0,0 +1,36 @@
+import * as Schema from "effect/Schema";
+
+//#region src/email-fixtures.d.ts
+/** A port failure as a fixture records it (mirrors `PortFailure` in `@yolk-sdk/conformance`). */
+type EmailEmulatorFailure = {
+  readonly kind: 'expected' | 'error';
+  readonly code: string;
+  readonly message: string;
+  readonly status?: number;
+};
+type EmailEmulatorFixtureFields = {
+  readonly id: string;
+  readonly port: string;
+  readonly method: string;
+  readonly request: Schema.Json;
+  readonly observed?: {
+    readonly account: string;
+    readonly date: string;
+  };
+  readonly note?: string;
+};
+/**
+ * One recorded `EmailClient` call (the plain-JSON shape of a `PortFixture`): exactly one of
+ * `response` or `failure`.
+ */
+type EmailEmulatorFixture = (EmailEmulatorFixtureFields & {
+  readonly response: Schema.Json;
+  readonly failure?: never;
+}) | (EmailEmulatorFixtureFields & {
+  readonly failure: EmailEmulatorFailure;
+  readonly response?: never;
+});
+declare const emailEmulatorFixtures: ReadonlyArray<EmailEmulatorFixture>;
+//#endregion
+export { EmailEmulatorFailure, EmailEmulatorFixture, emailEmulatorFixtures };
+//# sourceMappingURL=email-fixtures.d.mts.map

package/dist/email-fixtures.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-fixtures.d.mts","names":[],"sources":["../src/email-fixtures.ts"],"mappings":";;;;KAUY,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,MAAA;AAAA;AAAA,KAGN,0BAAA;EAAA,SACM,EAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;EAAA,SACA,OAAA,EAAS,MAAA,CAAO,IAAI;EAAA,SACpB,QAAA;IAAA,SAAsB,OAAA;IAAA,SAA0B,IAAA;EAAA;EAAA,SAChD,IAAA;AAAA;;;AAAI;AAOf;KAAY,oBAAA,IACP,0BAAA;EAAA,SAAwC,QAAA,EAAU,MAAA,CAAO,IAAA;EAAA,SAAe,OAAA;AAAA,MACxE,0BAAA;EAAA,SACU,OAAA,EAAS,oBAAA;EAAA,SACT,QAAA;AAAA;AAAA,cAGF,qBAAA,EAAuB,aAAa,CAAC,oBAAA"}