155 lines
4.5 KiB
TypeScript
155 lines
4.5 KiB
TypeScript
import type { Result } from "../../../application/result.ts";
|
|
import {
|
|
createFailure,
|
|
type ApiFailure,
|
|
} from "../../../contracts/errors.ts";
|
|
import type {
|
|
ReferenceCreateCommand,
|
|
ReferenceGateway,
|
|
ReferenceListFilters,
|
|
} from "../application/reference-feature-api.ts";
|
|
import type { ReferenceResource } from "../domain/reference-resource.ts";
|
|
|
|
type ReferenceOperationMap = Readonly<{
|
|
LIST_REFERENCE_RESOURCES: Readonly<{
|
|
request: Readonly<{
|
|
operationId: "LIST_REFERENCE_RESOURCES";
|
|
routeId: "REFERENCE_RESOURCE_LIST";
|
|
searchParams: ReferenceListFilters;
|
|
signal?: AbortSignal;
|
|
}>;
|
|
value: readonly ReferenceResource[];
|
|
}>;
|
|
CREATE_REFERENCE_RESOURCE: Readonly<{
|
|
request: Readonly<{
|
|
operationId: "CREATE_REFERENCE_RESOURCE";
|
|
routeId: "REFERENCE_RESOURCE_LIST";
|
|
body: ReferenceCreateCommand;
|
|
signal?: AbortSignal;
|
|
}>;
|
|
value: ReferenceResource;
|
|
}>;
|
|
GET_REFERENCE_RESOURCE: Readonly<{
|
|
request: Readonly<{
|
|
operationId: "GET_REFERENCE_RESOURCE";
|
|
routeId: "REFERENCE_RESOURCE_DETAIL";
|
|
pathParams: Readonly<{ resourceId: string }>;
|
|
signal?: AbortSignal;
|
|
}>;
|
|
value: ReferenceResource;
|
|
}>;
|
|
}>;
|
|
|
|
export type ReferenceOperationId = keyof ReferenceOperationMap;
|
|
|
|
export type ReferenceHttpRequest<
|
|
OperationId extends ReferenceOperationId,
|
|
> = ReferenceOperationMap[OperationId]["request"];
|
|
|
|
export type ReferenceHttpResult<
|
|
OperationId extends ReferenceOperationId,
|
|
> = Result<ReferenceOperationMap[OperationId]["value"], ApiFailure>;
|
|
|
|
export type RawReferenceHttpExecutor = Readonly<{
|
|
execute(
|
|
request: ReferenceHttpRequest<ReferenceOperationId>,
|
|
): Promise<Result<unknown, ApiFailure>>;
|
|
}>;
|
|
|
|
export function createReferenceHttpGateway(
|
|
http: RawReferenceHttpExecutor,
|
|
): ReferenceGateway {
|
|
return Object.freeze({
|
|
async list(
|
|
filters: ReferenceListFilters,
|
|
context?: Readonly<{ signal?: AbortSignal }>,
|
|
) {
|
|
const result = await http.execute({
|
|
operationId: "LIST_REFERENCE_RESOURCES",
|
|
routeId: "REFERENCE_RESOURCE_LIST",
|
|
searchParams: filters,
|
|
signal: context?.signal,
|
|
});
|
|
return projectListResult(result);
|
|
},
|
|
async create(
|
|
command: ReferenceCreateCommand,
|
|
context?: Readonly<{ signal?: AbortSignal }>,
|
|
) {
|
|
const result = await http.execute({
|
|
operationId: "CREATE_REFERENCE_RESOURCE",
|
|
routeId: "REFERENCE_RESOURCE_LIST",
|
|
body: command,
|
|
signal: context?.signal,
|
|
});
|
|
return projectResourceResult("CREATE_REFERENCE_RESOURCE", result);
|
|
},
|
|
async get(
|
|
resourceId: string,
|
|
context?: Readonly<{ signal?: AbortSignal }>,
|
|
) {
|
|
const result = await http.execute({
|
|
operationId: "GET_REFERENCE_RESOURCE",
|
|
routeId: "REFERENCE_RESOURCE_DETAIL",
|
|
pathParams: { resourceId },
|
|
signal: context?.signal,
|
|
});
|
|
return projectResourceResult("GET_REFERENCE_RESOURCE", result);
|
|
},
|
|
});
|
|
}
|
|
|
|
function projectListResult(
|
|
result: Result<unknown, ApiFailure>,
|
|
): ReferenceHttpResult<"LIST_REFERENCE_RESOURCES"> {
|
|
if (!result.ok) return result;
|
|
if (isReferenceResourceList(result.value)) {
|
|
return { ok: true, value: result.value };
|
|
}
|
|
return typedResultFailure("LIST_REFERENCE_RESOURCES");
|
|
}
|
|
|
|
function projectResourceResult(
|
|
operationId:
|
|
| "CREATE_REFERENCE_RESOURCE"
|
|
| "GET_REFERENCE_RESOURCE",
|
|
result: Result<unknown, ApiFailure>,
|
|
): Result<ReferenceResource, ApiFailure> {
|
|
if (!result.ok) return result;
|
|
if (isReferenceResource(result.value)) {
|
|
return { ok: true, value: result.value };
|
|
}
|
|
return typedResultFailure(operationId);
|
|
}
|
|
|
|
function typedResultFailure(operationId: ReferenceOperationId) {
|
|
return {
|
|
ok: false as const,
|
|
error: createFailure(
|
|
"MAPPING_CONTRACT_VIOLATION",
|
|
operationId,
|
|
0,
|
|
{ code: "BOUND_RESULT_TYPE_MISMATCH" },
|
|
),
|
|
};
|
|
}
|
|
|
|
function isReferenceResourceList(
|
|
value: unknown,
|
|
): value is readonly ReferenceResource[] {
|
|
return Array.isArray(value) && value.every(isReferenceResource);
|
|
}
|
|
|
|
function isReferenceResource(value: unknown): value is ReferenceResource {
|
|
if (!value || typeof value !== "object") return false;
|
|
const candidate = value as Readonly<Record<string, unknown>>;
|
|
return (
|
|
typeof candidate.id === "string" &&
|
|
candidate.id.length > 0 &&
|
|
typeof candidate.displayName === "string" &&
|
|
candidate.displayName.length > 0 &&
|
|
(candidate.createdAt === null ||
|
|
typeof candidate.createdAt === "string")
|
|
);
|
|
}
|