@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/contract/computer/step/step-failure.schema.d.mts

@@ -0,0 +1,13 @@
+import { CallerNotAllowedError } from "../../caller/caller-not-allowed.errors.mjs";
+import { UnauthenticatedError } from "../../caller/unauthenticated.errors.mjs";
+import { ActorUnavailableError } from "../../client/actor-unavailable.errors.mjs";
+import { InvalidRequestError } from "../../client/invalid-request.errors.mjs";
+import { ComputerHeldError } from "../computer-held.errors.mjs";
+import { ComputerLimitError } from "../computer-limit.errors.mjs";
+import { ComputerLostError } from "../computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../computers-unavailable.errors.mjs";
+import { Schema } from "effect";
+/** Every failure a computer client can answer, as a schema, so a step journals the one it settled with. */
+declare const StepFailure: Schema.Union<readonly [typeof ActorUnavailableError, typeof CallerNotAllowedError, typeof ComputerHeldError, typeof ComputerLimitError, typeof ComputerLostError, typeof ComputerNotFoundError, typeof ComputersUnavailableError, typeof InvalidRequestError, typeof UnauthenticatedError]>;
+export { StepFailure };

package/dist/contract/computer/step/step-failure.schema.mjs

@@ -0,0 +1,24 @@
+import { CallerNotAllowedError } from "../../caller/caller-not-allowed.errors.mjs";
+import { UnauthenticatedError } from "../../caller/unauthenticated.errors.mjs";
+import { ActorUnavailableError } from "../../client/actor-unavailable.errors.mjs";
+import { InvalidRequestError } from "../../client/invalid-request.errors.mjs";
+import { ComputerHeldError } from "../computer-held.errors.mjs";
+import { ComputerLimitError } from "../computer-limit.errors.mjs";
+import { ComputerLostError } from "../computer-lost.errors.mjs";
+import { ComputerNotFoundError } from "../computer-not-found.errors.mjs";
+import { ComputersUnavailableError } from "../computers-unavailable.errors.mjs";
+import { Schema } from "effect";
+// src/contract/computer/step/step-failure.schema.ts
+/** Every failure a computer client can answer, as a schema, so a step journals the one it settled with. */
+const StepFailure = Schema.Union([
+	ActorUnavailableError,
+	CallerNotAllowedError,
+	ComputerHeldError,
+	ComputerLimitError,
+	ComputerLostError,
+	ComputerNotFoundError,
+	ComputersUnavailableError,
+	InvalidRequestError,
+	UnauthenticatedError
+]);
+export { StepFailure };

package/dist/contract/computer/step/step-not-found.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const StepNotFoundError_base: Schema.Class<StepNotFoundError, Schema.TaggedStruct<"StepNotFoundError", {
+  readonly step: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The actor's journal holds no durable step with that key. */
+export declare class StepNotFoundError extends StepNotFoundError_base {}
+export {};

package/dist/contract/computer/step/step-not-found.errors.mjs

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+// src/contract/computer/step/step-not-found.errors.ts
+/** The actor's journal holds no durable step with that key. */
+var StepNotFoundError = class extends Schema.TaggedError()("StepNotFoundError", { step: Schema.String }) {};
+export { StepNotFoundError };

package/dist/contract/description/published-contract.pure.d.mts

@@ -0,0 +1,51 @@
+import { Duration, Effect, Option, Record as Record$1, Schema } from "effect";
+interface DeclaredMember {
+  readonly callers: Option.Option<readonly string[]>;
+  readonly error: Schema.Top;
+  readonly payload: Schema.Top;
+  readonly success: Schema.Top;
+}
+interface DeclaredQuery extends DeclaredMember {
+  /** Absent from an actor built before queries could declare it, which reads as fresh. */
+  readonly staleFor?: Option.Option<Duration.Duration>;
+}
+interface DeclaredActor {
+  readonly callers: Readonly<Record<string, Schema.Top>>;
+  readonly commands: Readonly<Record<string, DeclaredMember>>;
+  readonly create: Schema.Top;
+  readonly fileAccess: Option.Option<DeclaredMember>;
+  readonly key: Schema.Top;
+  readonly name: string;
+  readonly queries: Readonly<Record<string, DeclaredQuery>>;
+}
+interface MemberContract extends Schema.JsonObject {
+  readonly callers: readonly string[] | null;
+  readonly error: Schema.Json;
+  readonly payload: Schema.Json;
+  readonly success: Schema.Json;
+}
+interface QueryContract extends MemberContract {
+  /** How old an answer may be, in milliseconds, when the query declares `staleFor`; absent means always fresh. */
+  readonly staleForMs?: number;
+}
+interface ActorContract extends Schema.JsonObject {
+  readonly callers: Readonly<Record<string, Schema.Json>>;
+  readonly commands: Readonly<Record<string, MemberContract>>;
+  readonly create: Schema.Json;
+  /** Who may make file calls and what the actor's rule refuses with (`FileAccessDeniedError`); null without files. */
+  readonly files: MemberContract | null;
+  readonly key: Schema.Json;
+  readonly queries: Readonly<Record<string, QueryContract>>;
+}
+type PublishedContracts = Readonly<Record<string, ActorContract>>;
+type JsonNode = Record$1.ReadonlyRecord<string, Schema.Json>;
+interface References {
+  readonly definitions: JsonNode;
+  readonly node: Schema.Json;
+  readonly prefix: string;
+}
+declare const inlined: ({ definitions, node, prefix }: References) => Schema.Json;
+declare const recordedContracts: (actors: readonly DeclaredActor[]) => Effect.Effect<PublishedContracts, Schema.SchemaError>;
+declare const renderContracts: (contracts: PublishedContracts) => Effect.Effect<string, Schema.SchemaError>;
+declare const renderContract: (actor: DeclaredActor) => Effect.Effect<string, Schema.SchemaError>;
+export { inlined, recordedContracts, renderContract, renderContracts };

package/dist/contract/description/published-contract.pure.mjs

@@ -0,0 +1,75 @@
+import { Array, Duration, Effect, Option, Predicate, Record, Schema, String, pipe } from "effect";
+// src/contract/description/published-contract.pure.ts
+const DEFINITION_PREFIX = "#/$defs/";
+const decodeJson = Schema.decodeUnknownEffect(Schema.Json);
+const decodeDefinitions = Schema.decodeUnknownEffect(Schema.JsonObject);
+const encodeBaseline = Schema.encodeEffect(Schema.fromJsonString(Schema.Json, { space: 2 }));
+const isJsonObject = Schema.is(Schema.JsonObject);
+const isJsonArray = Schema.is(Schema.Array(Schema.Json));
+const referenceName = (node, prefix) => pipe(Record.get(node, "$ref"), Option.filter(Predicate.isString), Option.filter(String.startsWith(prefix)), Option.map(String.slice(prefix.length)));
+const inlinedObject = (node, inlining, inline) => {
+	const name = Option.filter(referenceName(node, inlining.prefix), (candidate) => !Array.contains(inlining.expanding, candidate));
+	const definition = Option.flatMap(name, (found) => Record.get(inlining.definitions, found));
+	if (Option.isSome(name) && Option.isSome(definition)) return inline(definition.value, {
+		...inlining,
+		expanding: [...inlining.expanding, name.value]
+	});
+	return Record.map(node, (value) => inline(value, inlining));
+};
+const inlinedNode = (node, inlining) => {
+	if (isJsonArray(node)) return Array.map(node, (item) => inlinedNode(item, inlining));
+	if (!isJsonObject(node)) return node;
+	return inlinedObject(node, inlining, inlinedNode);
+};
+const inlined = ({ definitions, node, prefix }) => inlinedNode(node, {
+	definitions,
+	expanding: [],
+	prefix
+});
+const jsonSchemaOf = Effect.fn("jsonSchemaOf")(function* jsonSchemaOf(schema) {
+	const document = Schema.toJsonSchemaDocument(schema);
+	const root = yield* decodeJson(document.schema);
+	const definitions = yield* decodeDefinitions(document.definitions);
+	return inlined({
+		definitions,
+		node: root,
+		prefix: DEFINITION_PREFIX
+	});
+});
+const memberContract = (member) => Effect.all({
+	callers: Effect.succeed(Option.getOrNull(member.callers)),
+	error: jsonSchemaOf(member.error),
+	payload: jsonSchemaOf(member.payload),
+	success: jsonSchemaOf(member.success)
+});
+const queryContract = (query) => Effect.map(memberContract(query), (member) => Option.match(Option.flatten(Option.fromUndefinedOr(query.staleFor)), {
+	onNone: () => member,
+	onSome: (age) => ({
+		...member,
+		staleForMs: Duration.toMillis(age)
+	})
+}));
+/** The actor's file declaration as published, or null when it declares no file calls. */
+const filesContract = (fileAccess) => Effect.map(Effect.transposeOption(Option.map(fileAccess, memberContract)), Option.getOrNull);
+const actorContract = (actor) => Effect.all({
+	callers: Effect.all(Record.map(actor.callers, jsonSchemaOf)),
+	commands: Effect.all(Record.map(actor.commands, memberContract)),
+	create: jsonSchemaOf(actor.create),
+	files: filesContract(actor.fileAccess),
+	key: jsonSchemaOf(actor.key),
+	queries: Effect.all(Record.map(actor.queries, queryContract))
+});
+const namedContract = (actor) => Effect.map(actorContract(actor), (contract) => [actor.name, contract]);
+const recordedContracts = (actors) => Effect.map(Effect.forEach(actors, namedContract), Record.fromEntries);
+const sortedObject = (node, sort) => {
+	const entries = Array.sortWith(Record.toEntries(node), ([key]) => key, String.Order);
+	return Record.fromEntries(Array.map(entries, ([key, value]) => [key, sort(value)]));
+};
+const sortedKeys = (node) => {
+	if (isJsonArray(node)) return Array.map(node, sortedKeys);
+	if (!isJsonObject(node)) return node;
+	return sortedObject(node, sortedKeys);
+};
+const renderContracts = (contracts) => Effect.map(encodeBaseline(sortedKeys(contracts)), (text) => `${text}\n`);
+const renderContract = (actor) => Effect.flatMap(actorContract(actor), (contract) => Effect.map(encodeBaseline(sortedKeys(contract)), (text) => `${text}\n`));
+export { inlined, recordedContracts, renderContract, renderContracts };

package/dist/contract/file/access/file-access-denied.errors.d.mts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+declare const FileAccessDeniedError_base: Schema.Class<FileAccessDeniedError, Schema.TaggedStruct<"FileAccessDeniedError", {
+  readonly access: Schema.Literals<readonly ["read", "write"]>;
+  readonly message: Schema.String;
+  readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The actor's `files.authorize` rule refused this caller's file call. */
+export declare class FileAccessDeniedError extends FileAccessDeniedError_base {}
+export {};

package/dist/contract/file/access/file-access-denied.errors.mjs

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+// src/contract/file/access/file-access-denied.errors.ts
+/** The actor's `files.authorize` rule refused this caller's file call. */
+var FileAccessDeniedError = class extends Schema.TaggedError()("FileAccessDeniedError", {
+	access: Schema.Literals(["read", "write"]),
+	message: Schema.String,
+	path: Schema.String
+}) {};
+export { FileAccessDeniedError };

package/dist/contract/file/access/file-access.contract.d.mts

@@ -0,0 +1,35 @@
+import { Query } from "../../command/command.contract.mjs";
+import { FileAccessDeniedError } from "./file-access-denied.errors.mjs";
+import { Schema } from "effect";
+/**
+ * What a file call asks the actor's `files.authorize` rule: `read` for a download, a listing or the usage (`path` is
+ * the file, or the listing's prefix), `write` for an upload (`path` is empty: the command that attaches the upload
+ * names its path, and is gated as a command).
+ */
+declare const FileAccessRequest: Schema.Struct<{
+  readonly access: Schema.Literals<readonly ["read", "write"]>;
+  readonly path: Schema.String;
+}>;
+/**
+ * An actor's file declaration: which caller kinds may make file calls at all. Each call then runs the actor's
+ * `files.authorize` rule as a query under the reserved member `akter.files`, so the engine admits the kind, reads the
+ * state and the verified principal, and refuses the call unless the rule succeeds.
+ */
+type FileAccess<Kinds extends string = string> = Query<typeof FileAccessRequest, typeof Schema.Void, typeof FileAccessDeniedError, Kinds>;
+/** How a file call's question travels to the host as the `akter.files` query's payload. */
+declare const fileAccessPayload: Schema.fromJsonString<Schema.toCodecJson<Schema.Struct<{
+  readonly access: Schema.Literals<readonly ["read", "write"]>;
+  readonly path: Schema.String;
+}>>>;
+/** How a host reads the rule's reply: the `akter.files` query's exit, as `HostedActor.runQuery` encodes it. */
+declare const fileAccessReply: Schema.fromJsonString<Schema.toCodecJson<Schema.Exit<Schema.Void, typeof FileAccessDeniedError, Schema.Defect>>>;
+/** The reserved query member a host runs an actor's `files.authorize` rule under. */
+declare const fileAccessMember = "akter.files";
+/**
+ * Declares which caller kinds may make file calls to an actor (`Akter.make`'s `files` option); without it, the actor has
+ * no file calls.
+ */
+declare const fileAccess: <const Kinds extends string>(options: {
+  readonly callers: readonly [Kinds, ...Kinds[]];
+}) => FileAccess<Kinds>;
+export { type FileAccess, type FileAccessDeniedError, FileAccessRequest, fileAccess, fileAccessMember, fileAccessPayload, fileAccessReply };

package/dist/contract/file/access/file-access.contract.mjs

@@ -0,0 +1,32 @@
+import { FileAccessDeniedError } from "./file-access-denied.errors.mjs";
+import { Option, Schema } from "effect";
+// src/contract/file/access/file-access.contract.ts
+/**
+* What a file call asks the actor's `files.authorize` rule: `read` for a download, a listing or the usage (`path` is
+* the file, or the listing's prefix), `write` for an upload (`path` is empty: the command that attaches the upload
+* names its path, and is gated as a command).
+*/
+const FileAccessRequest = Schema.Struct({
+	access: Schema.Literals(["read", "write"]),
+	path: Schema.String
+});
+/** How a file call's question travels to the host as the `akter.files` query's payload. */
+const fileAccessPayload = Schema.fromJsonString(Schema.toCodecJson(FileAccessRequest));
+/** The rule's outcome: allowed, refused with `FileAccessDeniedError`, or a defect. */
+const FileAccessExit = Schema.Exit(Schema.Void, FileAccessDeniedError, Schema.Defect());
+/** How a host reads the rule's reply: the `akter.files` query's exit, as `HostedActor.runQuery` encodes it. */
+const fileAccessReply = Schema.fromJsonString(Schema.toCodecJson(FileAccessExit));
+/** The reserved query member a host runs an actor's `files.authorize` rule under. */
+const fileAccessMember = "akter.files";
+/**
+* Declares which caller kinds may make file calls to an actor (`Akter.make`'s `files` option); without it, the actor has
+* no file calls.
+*/
+const fileAccess = (options) => ({
+	callers: Option.some(options.callers),
+	error: FileAccessDeniedError,
+	payload: FileAccessRequest,
+	staleFor: Option.none(),
+	success: Schema.Void
+});
+export { FileAccessRequest, fileAccess, fileAccessMember, fileAccessPayload, fileAccessReply };

package/dist/contract/file/actor-files.contract.d.mts

@@ -0,0 +1,50 @@
+import { ActorState } from "../state/actor-state.service.mjs";
+import { BlobTransferError } from "./blob-transfer.errors.mjs";
+import { FileNotFoundError } from "./file-not-found.errors.mjs";
+import { FilesUnavailableError } from "./files-unavailable.errors.mjs";
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { Effect, Option, Stream } from "effect";
+import { SqlError } from "effect/sql";
+interface FileRef {
+  readonly bytes: number;
+  readonly path: string;
+  readonly sha256: string;
+  readonly writtenAt: number;
+}
+interface FileListing {
+  readonly cursor?: string;
+  readonly limit?: number;
+  readonly prefix?: string;
+}
+interface FileRange {
+  readonly length: number;
+  readonly offset: number;
+}
+interface FilePage {
+  readonly cursor: Option.Option<string>;
+  readonly entries: readonly FileRef[];
+}
+interface FileUsagePage extends FilePage {
+  readonly bytes: bigint;
+}
+interface FileAttaching {
+  readonly now: number;
+  readonly path: string;
+  readonly receipt: string;
+}
+type FileFailure = BlobTransferError | FileNotFoundError | FilesUnavailableError | InvalidFileRequestError | SqlError.SqlError;
+interface FileReader {
+  readonly list: (listing?: FileListing) => Effect.Effect<FilePage, FileFailure>;
+  readonly fileUsage: (listing?: FileListing) => Effect.Effect<FileUsagePage, FileFailure>;
+  readonly read: (path: string, range?: FileRange) => Stream.Stream<Uint8Array, FileFailure>;
+}
+interface FileStorage extends FileReader {
+  readonly available: Effect.Effect<void, FilesUnavailableError>;
+  readonly attach: (attaching: FileAttaching) => Effect.Effect<FileRef, FileFailure>;
+  readonly remove: (path: string) => Effect.Effect<void, FileFailure>;
+}
+interface ActorFiles extends FileReader {
+  readonly attach: (path: string, receipt: string) => Effect.Effect<FileRef, FileFailure, ActorState>;
+  readonly remove: (path: string) => Effect.Effect<void, FileFailure, ActorState>;
+}
+export type { ActorFiles, FileAttaching, FileFailure, FileListing, FilePage, FileRange, FileReader, FileRef, FileStorage, FileUsagePage };

package/dist/contract/file/actor-files.contract.mjs

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

package/dist/contract/file/blob-transfer.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const BlobTransferError_base: Schema.Class<BlobTransferError, Schema.TaggedStruct<"BlobTransferError", {
+  readonly blob: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class BlobTransferError extends BlobTransferError_base {}
+export {};

package/dist/contract/file/blob-transfer.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/contract/file/blob-transfer.errors.ts
+var BlobTransferError = class extends Schema.TaggedError()("BlobTransferError", {
+	blob: Schema.String,
+	message: Schema.String
+}) {};
+export { BlobTransferError };

package/dist/contract/file/file-client-failure.contract.d.mts

@@ -0,0 +1,24 @@
+import { UnauthenticatedError } from "../caller/unauthenticated.errors.mjs";
+import { ActorErasedError } from "../actor/actor-erased.errors.mjs";
+import { ActorUnavailableError } from "../client/actor-unavailable.errors.mjs";
+import { BillingUnavailableError } from "../spend/billing-unavailable.errors.mjs";
+import { CallerNotAllowedError } from "../caller/caller-not-allowed.errors.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { SpendCapReachedError } from "../spend/spend-cap-reached.errors.mjs";
+import { StorageLimitError } from "../client/storage-limit.errors.mjs";
+import "../client/client-failure.contract.mjs";
+import { BlobTransferError } from "./blob-transfer.errors.mjs";
+import { FileAccessDeniedError } from "./access/file-access-denied.errors.mjs";
+import { FileNotFoundError } from "./file-not-found.errors.mjs";
+import { FilesUnavailableError } from "./files-unavailable.errors.mjs";
+import { FileTooLargeError } from "./rpc/file-too-large.errors.mjs";
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { SqlError } from "effect/sql";
+/**
+ * What a file client can fail with. A network upload past the server's largest file fails with `FileTooLargeError`.
+ * A network client adds the caller's refusals, `CallerNotAllowedError`, `FileAccessDeniedError` (the actor's
+ * `files.authorize` rule) and `UnauthenticatedError`, and Akter Cloud's refusals, `SpendCapReachedError`, `BillingUnavailableError` and `StorageLimitError`; a
+ * host's own client never refuses its caller.
+ */
+type FileClientFailure = ActorErasedError | ActorUnavailableError | BillingUnavailableError | BlobTransferError | CallerNotAllowedError | FileAccessDeniedError | FileNotFoundError | FilesUnavailableError | FileTooLargeError | InvalidFileRequestError | InvalidRequestError | SpendCapReachedError | StorageLimitError | SqlError.SqlError | UnauthenticatedError;
+export type { FileClientFailure };

package/dist/contract/file/file-client-failure.contract.mjs

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

package/dist/contract/file/file-client.adapter.d.mts

@@ -0,0 +1,17 @@
+import { ActorDefinition } from "../actor/actor.contract.mjs";
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { FileAddress, FileClient } from "./file-client.contract.mjs";
+import { FilesUnavailableError } from "./files-unavailable.errors.mjs";
+import { Context, Effect } from "effect";
+interface FileClientSource {
+  readonly definition: ActorDefinition;
+  readonly name: string;
+}
+type FileClientOf<Definition extends ActorDefinition> = (key: Definition["key"]["Type"]) => Effect.Effect<FileClient, FilesUnavailableError | InvalidRequestError>;
+declare const ActorFileClients_base: Context.ServiceClass<ActorFileClients, "@akterjs/effect/contract/file/file-client.adapter/ActorFileClients", {
+  readonly connect: (address: FileAddress) => FileClient;
+}>;
+export declare class ActorFileClients extends ActorFileClients_base {
+  static clientOf<Definition extends ActorDefinition>(source: FileClientSource): FileClientOf<Definition>;
+}
+export type { FileClientOf };

package/dist/contract/file/file-client.adapter.mjs

@@ -0,0 +1,21 @@
+import { InvalidRequestError } from "../client/invalid-request.errors.mjs";
+import { FilesUnavailableError } from "./files-unavailable.errors.mjs";
+import { Context, Effect, Option, Schema } from "effect";
+// src/contract/file/file-client.adapter.ts
+var ActorFileClients = class ActorFileClients extends Context.Service()("@akterjs/effect/contract/file/file-client.adapter/ActorFileClients") {
+	static clientOf({ definition, name }) {
+		return (key) => Effect.gen(function* connectFiles() {
+			const clients = yield* Effect.serviceOption(ActorFileClients);
+			if (Option.isNone(clients)) return yield* FilesUnavailableError.make({ message: "files aren't available on this host" });
+			const encoded = yield* Schema.encodeEffect(definition.key)(key).pipe(Effect.mapError(() => InvalidRequestError.make({
+				actor: name,
+				message: "the actor key is invalid"
+			})));
+			return clients.value.connect({
+				actor: name,
+				key: encoded
+			});
+		});
+	}
+};
+export { ActorFileClients };

package/dist/contract/file/file-client.contract.d.mts

@@ -0,0 +1,14 @@
+import { FileListing, FilePage, FileRange, FileUsagePage } from "./actor-files.contract.mjs";
+import { FileClientFailure } from "./file-client-failure.contract.mjs";
+import { Effect, Stream } from "effect";
+interface FileAddress {
+  readonly actor: string;
+  readonly key: string;
+}
+interface FileClient {
+  readonly download: (path: string, range?: FileRange) => Stream.Stream<Uint8Array, FileClientFailure>;
+  readonly fileUsage: (listing?: FileListing) => Effect.Effect<FileUsagePage, FileClientFailure>;
+  readonly list: (listing?: FileListing) => Effect.Effect<FilePage, FileClientFailure>;
+  readonly upload: <Failure, Services>(source: Stream.Stream<Uint8Array, Failure, Services>) => Effect.Effect<string, Failure | FileClientFailure, Services>;
+}
+export type { FileAddress, FileClient, FileClientFailure, FileListing, FilePage, FileRange, FileUsagePage };

package/dist/contract/file/file-client.contract.mjs

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

package/dist/contract/file/file-listing.pure.d.mts

@@ -0,0 +1,6 @@
+import { FileListing } from "./actor-files.contract.mjs";
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { Effect } from "effect";
+type CompleteListing = Required<FileListing>;
+declare const fileListingOf: ({ cursor, limit, prefix }: FileListing) => Effect.Effect<CompleteListing, InvalidFileRequestError>;
+export { type CompleteListing, fileListingOf };

package/dist/contract/file/file-listing.pure.mjs

@@ -0,0 +1,18 @@
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { Effect, String } from "effect";
+// src/contract/file/file-listing.pure.ts
+const defaultLimit = 100;
+const largestLimit = 1e3;
+const smallestLimit = 1;
+const fileListingOf = ({ cursor = "", limit = defaultLimit, prefix = "" }) => {
+	if (!Number.isSafeInteger(limit) || limit < smallestLimit || limit > largestLimit) return Effect.fail(InvalidFileRequestError.make({
+		message: "a file page limit must be an integer from 1 to 1000",
+		path: prefix
+	}));
+	return Effect.succeed({
+		cursor: String.normalize("NFC")(cursor),
+		limit,
+		prefix: String.normalize("NFC")(prefix)
+	});
+};
+export { fileListingOf };

package/dist/contract/file/file-not-found.errors.d.mts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const FileNotFoundError_base: Schema.Class<FileNotFoundError, Schema.TaggedStruct<"FileNotFoundError", {
+  readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class FileNotFoundError extends FileNotFoundError_base {}
+export {};

package/dist/contract/file/file-not-found.errors.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/contract/file/file-not-found.errors.ts
+var FileNotFoundError = class extends Schema.TaggedError()("FileNotFoundError", { path: Schema.String }) {};
+export { FileNotFoundError };

package/dist/contract/file/file-path.pure.d.mts

@@ -0,0 +1,4 @@
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { Effect } from "effect";
+declare const filePathOf: (path: string) => Effect.Effect<string, InvalidFileRequestError>;
+export { filePathOf };

package/dist/contract/file/file-path.pure.mjs

@@ -0,0 +1,38 @@
+import { InvalidFileRequestError } from "./invalid-file-request.errors.mjs";
+import { Array, Effect, Option, String } from "effect";
+// src/contract/file/file-path.pure.ts
+const dotSegments = [".", ".."];
+const segmentsOf = String.split("/");
+const pathRules = [
+	{
+		refuses: String.includes("\0"),
+		why: "contains a NUL character"
+	},
+	{
+		refuses: String.includes("\\"),
+		why: "contains a backslash"
+	},
+	{
+		refuses: String.startsWith("/"),
+		why: "is absolute"
+	},
+	{
+		refuses: (path) => Array.some(segmentsOf(path), String.isEmpty),
+		why: "has an empty segment"
+	},
+	{
+		refuses: (path) => Array.some(segmentsOf(path), (segment) => Array.contains(dotSegments, segment)),
+		why: "has a \".\" or \"..\" segment"
+	}
+];
+const filePathOf = (path) => {
+	const normalized = String.normalize("NFC")(path);
+	return Option.match(Array.findFirst(pathRules, (rule) => rule.refuses(normalized)), {
+		onNone: () => Effect.succeed(normalized),
+		onSome: ({ why }) => Effect.fail(InvalidFileRequestError.make({
+			message: `the file path ${path} ${why}`,
+			path
+		}))
+	});
+};
+export { filePathOf };

package/dist/contract/file/files-unavailable.errors.d.mts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const FilesUnavailableError_base: Schema.Class<FilesUnavailableError, Schema.TaggedStruct<"FilesUnavailableError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class FilesUnavailableError extends FilesUnavailableError_base {}
+export {};

package/dist/contract/file/files-unavailable.errors.mjs

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+// src/contract/file/files-unavailable.errors.ts
+var FilesUnavailableError = class extends Schema.TaggedError()("FilesUnavailableError", { message: Schema.String }) {};
+export { FilesUnavailableError };

package/dist/contract/file/invalid-file-request.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const InvalidFileRequestError_base: Schema.Class<InvalidFileRequestError, Schema.TaggedStruct<"InvalidFileRequestError", {
+  readonly message: Schema.String;
+  readonly path: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class InvalidFileRequestError extends InvalidFileRequestError_base {}
+export {};

package/dist/contract/file/invalid-file-request.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/contract/file/invalid-file-request.errors.ts
+var InvalidFileRequestError = class extends Schema.TaggedError()("InvalidFileRequestError", {
+	message: Schema.String,
+	path: Schema.String
+}) {};
+export { InvalidFileRequestError };