feat: replace ScrapboxResponse with TargetedResponse interface

- Remove option-t dependency
- Implement TargetedResponse interface following @takker/gyazo@0.4.0
- Use @std/http for StatusCode and SuccessfulStatus
- Add utility functions for response creation
- Translate Japanese comments to English
- Update all REST API endpoints to use new interface

Author: devin-ai-integration[bot]

rest-api-redesign.patch

@@ -1,5 +1,6 @@
 import { getProfile } from "./profile.ts";
-import { ScrapboxResponse } from "./response.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse } from "./utils.ts";
 import type { HTTPError } from "./responseIntoResult.ts";
 import type { AbortError, NetworkError } from "./robustFetch.ts";
 import type { ExtendedOptions } from "./options.ts";
@@ -16,11 +17,11 @@ export const cookie = (sid: string): string => `connect.sid=${sid}`;
  */
 export const getCSRFToken = async (
   init?: ExtendedOptions,
-): Promise<ScrapboxResponse<string, NetworkError | AbortError | HTTPError>> => {
+): Promise<TargetedResponse<200 | 400 | 404 | 0 | 499, string | NetworkError | AbortError | HTTPError>> => {
   // deno-lint-ignore no-explicit-any
   const csrf = init?.csrf ?? (globalThis as any)._csrf;
-  if (csrf) return ScrapboxResponse.ok(csrf);
+  if (csrf) return createSuccessResponse(csrf);
 
   const profile = await getProfile(init);
-  return profile.ok ? ScrapboxResponse.ok(profile.data.csrfToken) : profile;
+  return profile.ok ? createSuccessResponse(profile.data.csrfToken) : profile;
 };

rest/auth.ts

@@ -0,0 +1,20 @@
+import type {
+  BadRequestError,
+  InvalidURLError,
+  NoQueryError,
+  NotFoundError,
+  NotLoggedInError,
+  NotMemberError,
+  NotPrivilegeError,
+  SessionError,
+} from "@cosense/types/rest";
+
+export type RESTError =
+  | BadRequestError
+  | NotFoundError
+  | NotLoggedInError
+  | NotMemberError
+  | SessionError
+  | InvalidURLError
+  | NoQueryError
+  | NotPrivilegeError;

rest/errors.ts

@@ -6,8 +6,9 @@ import type {
 import { cookie } from "./auth.ts";
 import { encodeTitleURI } from "../title.ts";
 import { type BaseOptions, setDefaults } from "./options.ts";
-import { ScrapboxResponse } from "./response.ts";
 import { parseHTTPError } from "./parseHTTPError.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse, createTargetedResponse } from "./utils.ts";
 import type { FetchError } from "./mod.ts";
 
 const getCodeBlock_toRequest: GetCodeBlock["toRequest"] = (
@@ -27,10 +28,10 @@ const getCodeBlock_toRequest: GetCodeBlock["toRequest"] = (
 };
 
 const getCodeBlock_fromResponse: GetCodeBlock["fromResponse"] = async (res) => {
-  const response = ScrapboxResponse.from<string, CodeBlockError>(res);
+  const response = createTargetedResponse<200 | 400 | 404, CodeBlockError>(res);
 
   if (response.status === 404 && response.headers.get("Content-Type")?.includes?.("text/plain")) {
-    return ScrapboxResponse.error({
+    return createErrorResponse(404, {
       name: "NotFoundError",
       message: "Code block is not found",
     });
@@ -43,7 +44,7 @@ const getCodeBlock_fromResponse: GetCodeBlock["fromResponse"] = async (res) => {
 
   if (response.ok) {
     const text = await response.text();
-    return ScrapboxResponse.ok(text);
+    return createSuccessResponse(text);
   }
 
   return response;
@@ -70,14 +71,14 @@ export interface GetCodeBlock {
    * @param res 応答
    * @return コード
    */
-  fromResponse: (res: Response) => Promise<ScrapboxResponse<string, CodeBlockError>>;
+  fromResponse: (res: Response) => Promise<TargetedResponse<200 | 400 | 404, string | CodeBlockError>>;
 
   (
     project: string,
     title: string,
     filename: string,
     options?: BaseOptions,
-  ): Promise<ScrapboxResponse<string, CodeBlockError | FetchError>>;
+  ): Promise<TargetedResponse<200 | 400 | 404, string | CodeBlockError | FetchError>>;
 }
 export type CodeBlockError =
   | NotFoundError

rest/getCodeBlock.ts

@@ -1,8 +1,9 @@
 import type { NotLoggedInError } from "@cosense/types/rest";
 import { cookie } from "./auth.ts";
 import { parseHTTPError } from "./parseHTTPError.ts";
-import { ScrapboxResponse } from "./response.ts";
 import { type BaseOptions, setDefaults } from "./options.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse, createTargetedResponse } from "./utils.ts";
 import type { FetchError } from "./mod.ts";
 
 export interface GetGyazoTokenOptions extends BaseOptions {
@@ -22,7 +23,7 @@ export type GyazoTokenError = NotLoggedInError | HTTPError;
  */
 export const getGyazoToken = async (
   init?: GetGyazoTokenOptions,
-): Promise<ScrapboxResponse<string | undefined, GyazoTokenError | FetchError>> => {
+): Promise<TargetedResponse<200 | 400 | 404, string | undefined | GyazoTokenError | FetchError>> => {
   const { fetch, sid, hostName, gyazoTeamsName } = setDefaults(init ?? {});
   const req = new Request(
     `https://${hostName}/api/login/gyazo/oauth-upload/token${
@@ -32,13 +33,13 @@ export const getGyazoToken = async (
   );
 
   const res = await fetch(req);
-  const response = ScrapboxResponse.from<string | undefined, GyazoTokenError>(res);
+  const response = createTargetedResponse<200 | 400 | 404, GyazoTokenError>(res);
 
   await parseHTTPError(response, ["NotLoggedInError"]);
 
   if (response.ok) {
     const json = await response.json();
-    return ScrapboxResponse.ok(json.token as string | undefined);
+    return createSuccessResponse(json.token as string | undefined);
   }
 
   return response;

rest/getGyazoToken.ts

@@ -6,8 +6,9 @@ import type {
 } from "@cosense/types/rest";
 import { cookie, getCSRFToken } from "./auth.ts";
 import { parseHTTPError } from "./parseHTTPError.ts";
-import { ScrapboxResponse } from "./response.ts";
 import { type ExtendedOptions, setDefaults } from "./options.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse, createTargetedResponse } from "./utils.ts";
 import type { FetchError } from "./mod.ts";
 
 export type TweetInfoError =
@@ -25,7 +26,7 @@ export type TweetInfoError =
 export const getTweetInfo = async (
   url: string | URL,
   init?: ExtendedOptions,
-): Promise<ScrapboxResponse<TweetInfo, TweetInfoError | FetchError>> => {
+): Promise<TargetedResponse<200 | 400 | 404 | 422, TweetInfo | TweetInfoError | FetchError>> => {
   const { sid, hostName, fetch } = setDefaults(init ?? {});
 
   const csrfToken = await getCSRFToken(init);
@@ -47,11 +48,11 @@ export const getTweetInfo = async (
   );
 
   const res = await fetch(req);
-  const response = ScrapboxResponse.from<TweetInfo, TweetInfoError>(res);
+  const response = createTargetedResponse<200 | 400 | 404 | 422, TweetInfoError>(res);
 
   if (response.status === 422) {
     const json = await response.json();
-    return ScrapboxResponse.error({
+    return createErrorResponse(422, {
       name: "InvalidURLError",
       message: json.message as string,
     });

rest/getTweetInfo.ts

@@ -5,8 +5,9 @@ import type {
 } from "@cosense/types/rest";
 import { cookie, getCSRFToken } from "./auth.ts";
 import { parseHTTPError } from "./parseHTTPError.ts";
-import { ScrapboxResponse } from "./response.ts";
 import { type ExtendedOptions, setDefaults } from "./options.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse, createTargetedResponse } from "./utils.ts";
 import type { FetchError } from "./mod.ts";
 
 export type WebPageTitleError =
@@ -24,7 +25,7 @@ export type WebPageTitleError =
 export const getWebPageTitle = async (
   url: string | URL,
   init?: ExtendedOptions,
-): Promise<ScrapboxResponse<string, WebPageTitleError | FetchError>> => {
+): Promise<TargetedResponse<200 | 400 | 404, string | WebPageTitleError | FetchError>> => {
   const { sid, hostName, fetch } = setDefaults(init ?? {});
 
   const csrfToken = await getCSRFToken(init);
@@ -46,7 +47,7 @@ export const getWebPageTitle = async (
   );
 
   const res = await fetch(req);
-  const response = ScrapboxResponse.from<string, WebPageTitleError>(res);
+  const response = createTargetedResponse<200 | 400 | 404, WebPageTitleError>(res);
 
   await parseHTTPError(response, [
     "SessionError",
@@ -56,7 +57,7 @@ export const getWebPageTitle = async (
 
   if (response.ok) {
     const { title } = await response.json() as { title: string };
-    return ScrapboxResponse.ok(title);
+    return createSuccessResponse(title);
   }
 
   return response;

rest/getWebPageTitle.ts

@@ -0,0 +1,123 @@
+import type { JsonValue } from "jsr:/@std/json@^1.0.1/types";
+import type { IsAny } from "jsr:/@std/testing@^1.0.8/types";
+export type { IsAny, JsonValue };
+
+/**
+ * Check if a property {@linkcode K} is optional in {@linkcode T}.
+ *
+ * ```ts
+ * import type { Assert } from "@std/testing/types";
+ *
+ * type _1 = Assert<IsOptional<{ a?: number }, "a">, true>;
+ * type _2 = Assert<IsOptional<{ a?: undefined }, "a">, true>;
+ * type _3 = Assert<IsOptional<{ a?: number | undefined }, "a">, true>;
+ * type _4 = Assert<IsOptional<{ a: number }, "a">, false>;
+ * type _5 = Assert<IsOptional<{ a: undefined }, "a">, false>;
+ * type _6 = Assert<IsOptional<{ a: number | undefined }, "a">, false>;
+ * ```
+ * @internal
+ *
+ * @see https://dev.to/zirkelc/typescript-how-to-check-for-optional-properties-3192
+ */
+export type IsOptional<T, K extends keyof T> =
+  Record<PropertyKey, never> extends Pick<T, K> ? true : false;
+
+/**
+ * A type that is compatible with JSON.
+ *
+ * ```ts
+ * import type { JsonValue } from "@std/json/types";
+ * import { assertType } from "@std/testing/types";
+ *
+ * type IsJsonCompatible<T> = [T] extends [JsonCompatible<T>] ? true : false;
+ *
+ * assertType<IsJsonCompatible<null>>(true);
+ * assertType<IsJsonCompatible<false>>(true);
+ * assertType<IsJsonCompatible<0>>(true);
+ * assertType<IsJsonCompatible<"">>(true);
+ * assertType<IsJsonCompatible<[]>>(true);
+ * assertType<IsJsonCompatible<JsonValue>>(true);
+ * assertType<IsJsonCompatible<symbol>>(false);
+ * // deno-lint-ignore no-explicit-any
+ * assertType<IsJsonCompatible<any>>(false);
+ * assertType<IsJsonCompatible<unknown>>(false);
+ * assertType<IsJsonCompatible<undefined>>(false);
+ * // deno-lint-ignore ban-types
+ * assertType<IsJsonCompatible<Function>>(false);
+ * assertType<IsJsonCompatible<() => void>>(false);
+ * assertType<IsJsonCompatible<number | undefined>>(false);
+ * assertType<IsJsonCompatible<symbol | undefined>>(false);
+ *
+ * assertType<IsJsonCompatible<object>>(true);
+ * // deno-lint-ignore ban-types
+ * assertType<IsJsonCompatible<{}>>(true);
+ * assertType<IsJsonCompatible<{ a: 0 }>>(true);
+ * assertType<IsJsonCompatible<{ a: "" }>>(true);
+ * assertType<IsJsonCompatible<{ a: [] }>>(true);
+ * assertType<IsJsonCompatible<{ a: null }>>(true);
+ * assertType<IsJsonCompatible<{ a: false }>>(true);
+ * assertType<IsJsonCompatible<{ a: boolean }>>(true);
+ * assertType<IsJsonCompatible<{ a: Date }>>(false);
+ * assertType<IsJsonCompatible<{ a?: Date }>>(false);
+ * assertType<IsJsonCompatible<{ a: number }>>(true);
+ * assertType<IsJsonCompatible<{ a?: number }>>(true);
+ * assertType<IsJsonCompatible<{ a: undefined }>>(false);
+ * assertType<IsJsonCompatible<{ a?: undefined }>>(true);
+ * assertType<IsJsonCompatible<{ a: number | undefined }>>(false);
+ * assertType<IsJsonCompatible<{ a: null }>>(true);
+ * assertType<IsJsonCompatible<{ a: null | undefined }>>(false);
+ * assertType<IsJsonCompatible<{ a?: null }>>(true);
+ * assertType<IsJsonCompatible<{ a: JsonValue }>>(true);
+ * // deno-lint-ignore no-explicit-any
+ * assertType<IsJsonCompatible<{ a: any }>>(false);
+ * assertType<IsJsonCompatible<{ a: unknown }>>(false);
+ * // deno-lint-ignore ban-types
+ * assertType<IsJsonCompatible<{ a: Function }>>(false);
+ * // deno-lint-ignore no-explicit-any
+ * assertType<IsJsonCompatible<{ a: () => any }>>(false);
+ * // deno-lint-ignore no-explicit-any
+ * assertType<IsJsonCompatible<{ a: (() => any) | number }>>(false);
+ * // deno-lint-ignore no-explicit-any
+ * assertType<IsJsonCompatible<{ a?: () => any }>>(false);
+ * class A {
+ *   a = 34;
+ * }
+ * assertType<IsJsonCompatible<A>>(true);
+ * class B {
+ *   fn() {
+ *     return "hello";
+ *   };
+ * }
+ * assertType<IsJsonCompatible<B>>(false);
+ *
+ * assertType<IsJsonCompatible<{ a: number } | { a: string }>>(true);
+ * assertType<IsJsonCompatible<{ a: number } | { a: () => void }>>(false);
+ *
+ * assertType<IsJsonCompatible<{ a: { aa: string } }>>(true);
+ * interface D {
+ *   aa: string;
+ * }
+ * assertType<IsJsonCompatible<D>>(true);
+ * interface E {
+ *   a: D;
+ * }
+ * assertType<IsJsonCompatible<E>>(true);
+ * interface F {
+ *   _: E;
+ * }
+ * assertType<IsJsonCompatible<F>>(true);
+ * ```
+ *
+ * @see This implementation is heavily inspired by https://github.com/microsoft/TypeScript/issues/1897#issuecomment-580962081 .
+ */
+export type JsonCompatible<T> =
+  // deno-lint-ignore ban-types
+  [Extract<T, Function | symbol | undefined>] extends [never] ? {
+    [K in keyof T]: [IsAny<T[K]>] extends [true] ? never
+      : T[K] extends JsonValue ? T[K]
+      : [IsOptional<T, K>] extends [true]
+        ? JsonCompatible<Exclude<T[K], undefined>> | Extract<T[K], undefined>
+      : undefined extends T[K] ? never
+      : JsonCompatible<T[K]>;
+  }
+  : never;

rest/json_compatible.ts

@@ -1,6 +1,7 @@
 import type { GuestUser, MemberUser } from "@cosense/types/rest";
 import { cookie } from "./auth.ts";
-import { ScrapboxResponse } from "./response.ts";
+import type { TargetedResponse } from "./targeted_response.ts";
+import { createSuccessResponse, createErrorResponse, createTargetedResponse } from "./utils.ts";
 import type { FetchError } from "./robustFetch.ts";
 import { type BaseOptions, setDefaults } from "./options.ts";
 
@@ -20,11 +21,11 @@ export interface GetProfile {
   fromResponse: (
     res: Response,
   ) => Promise<
-    ScrapboxResponse<MemberUser | GuestUser, ProfileError>
+    TargetedResponse<200 | 400 | 404, MemberUser | GuestUser | ProfileError>
   >;
 
   (init?: BaseOptions): Promise<
-    ScrapboxResponse<MemberUser | GuestUser, ProfileError | FetchError>
+    TargetedResponse<200 | 400 | 404 | 0 | 499, MemberUser | GuestUser | ProfileError | FetchError>
   >;
 }
 
@@ -41,7 +42,7 @@ const getProfile_toRequest: GetProfile["toRequest"] = (
 };
 
 const getProfile_fromResponse: GetProfile["fromResponse"] = async (res) => {
-  const response = ScrapboxResponse.from<MemberUser | GuestUser, ProfileError>(res);
+  const response = createTargetedResponse<200 | 400 | 404, MemberUser | GuestUser | ProfileError>(res);
   return response;
 };