graze-client 0.8.1 → 0.9.0

package/src/GrazeClient.ts

@@ -1,90 +1,92 @@
-import {
-  FetchHttpClient,
-  HttpApi,
-  HttpApiClient,
-  HttpApiEndpoint,
-  HttpApiGroup,
-  HttpApiSchema,
-  HttpClient,
-  HttpClientRequest
-} from "@effect/platform"
-import { Config, Data, Effect, Redacted, Schema } from "effect"
+import { Config, Context, Data, Effect, Layer, Redacted, Schema } from "effect";
 import {
   AlgoUpdateResponse,
   GetAlgoResponse,
   GetAlgorithmsResponse,
   HidePostBody,
-  UnhidePostBody
-} from "./schema/shared.js"
+  UnhidePostBody,
+} from "./schema/shared.js";
 
-import { FeedIdParam, UserIdParam } from "./common.js"
-import * as Form from "./schema/UpdateAlgorithmPayload.js"
-import { StickyPostsApiGroup } from "./stickyposts.js"
+import { FeedIdParam, UserIdParam } from "./common.js";
+import * as Form from "./schema/UpdateAlgorithmPayload.js";
+import { StickyPostsApiGroup } from "./stickyposts.js";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as HttpApi from "effect/unstable/httpapi/HttpApi";
+import * as HttpApiClient from "effect/unstable/httpapi/HttpApiClient";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+import * as HttpApiSchema from "effect/unstable/httpapi/HttpApiSchema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 
 function isStringOrBlob(val: unknown): val is string | Blob {
-  return typeof val === "string" || val instanceof Blob
+  return typeof val === "string" || val instanceof Blob;
 }
 
 const encodeForm = (obj: Form.FullForm) =>
-  Effect.gen(function*() {
-    const encoded = yield* Schema.encode(Form.FullForm)(obj)
-    const formData = new FormData()
+  Effect.gen(function* () {
+    const encoded = yield* Schema.encodeEffect(Form.FullForm)(obj);
+    const formData = new FormData();
     for (const key in encoded) {
       if (Object.prototype.hasOwnProperty.call(encoded, key)) {
-        const val = encoded[key as keyof Form.FullForm]
+        const val = encoded[key as keyof Form.FullForm];
         if (isStringOrBlob(val)) {
-          formData.append(key, val)
+          formData.append(key, val);
         }
       }
     }
-    return formData
-  })
+    return formData;
+  });
 
 const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
   .add(
-    HttpApiEndpoint.get("getFeeds")`/app/my_feeds`
-      .addSuccess(GetAlgorithmsResponse)
-      .setPayload(
-        Schema.Struct({
-          user_id: UserIdParam
-        })
-      )
+    HttpApiEndpoint.get("getFeeds", "/app/my_feeds", {
+      // v3 GET `setPayload` serialised to query params (GET has no body); v4
+      // expresses that as `query`.
+      query: Schema.Struct({
+        user_id: UserIdParam,
+      }),
+      success: GetAlgorithmsResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.get("getFeed")`/app/my_feeds/${FeedIdParam}`.addSuccess(
-      GetAlgoResponse
-    )
+    HttpApiEndpoint.get("getFeed", "/app/my_feeds/:feedId", {
+      params: { feedId: FeedIdParam },
+      success: GetAlgoResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("updateAlgorithm")`/app/edit_algo_image`
-      .setPayload(HttpApiSchema.Multipart(Form.FullForm))
-      .addSuccess(AlgoUpdateResponse)
+    HttpApiEndpoint.post("updateAlgorithm", "/app/edit_algo_image", {
+      payload: Form.FullForm.pipe(HttpApiSchema.asMultipart()),
+      success: AlgoUpdateResponse,
+    }),
   )
   .add(
-    HttpApiEndpoint.get(
-      "publishAlgorithm"
-    )`/app/publish_algo/${FeedIdParam}`.addSuccess(Schema.Unknown)
+    HttpApiEndpoint.get("publishAlgorithm", "/app/publish_algo/:feedId", {
+      params: { feedId: FeedIdParam },
+      success: Schema.Unknown,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("hidePost")`/app/hide_post`
-      .setPayload(HidePostBody)
-      .addSuccess(Schema.Unknown)
+    HttpApiEndpoint.post("hidePost", "/app/hide_post", {
+      payload: HidePostBody,
+      success: Schema.Unknown,
+    }),
   )
   .add(
-    HttpApiEndpoint.post("unhidePost")`/app/unhide_post`
-      .setPayload(UnhidePostBody)
-      .addSuccess(Schema.Unknown)
-  )
+    HttpApiEndpoint.post("unhidePost", "/app/unhide_post", {
+      payload: UnhidePostBody,
+      success: Schema.Unknown,
+    }),
+  );
 
 class GrazeApiDef extends HttpApi.make("grazeApi")
   .add(GrazeApiGroup)
-  .add(StickyPostsApiGroup)
-  .addError(Schema.Unknown)
-{}
+  .add(StickyPostsApiGroup) {}
 
-const grazeLive = Effect.gen(function*() {
-  const baseUrl = yield* Config.url("GRAZE_API_URL")
-  const cookie = yield* Config.redacted("GRAZE_COOKIE")
+const grazeLive = Effect.gen(function* () {
+  const baseUrl = yield* Config.url("GRAZE_API_URL");
+  const cookie = yield* Config.redacted("GRAZE_COOKIE");
 
   const client = yield* HttpApiClient.make(GrazeApiDef, {
     baseUrl: baseUrl.toString(),
@@ -93,38 +95,43 @@ const grazeLive = Effect.gen(function*() {
         HttpClient.filterStatusOk,
         HttpClient.mapRequest(
           HttpClientRequest.setHeaders({
-            cookie: Redacted.value(cookie)
-          })
-        )
-      )
-  })
+            cookie: Redacted.value(cookie),
+          }),
+        ),
+      ),
+  });
 
   const updateAlgorithm = (data: Form.FullForm) =>
-    Effect.gen(function*() {
-      const formData = yield* encodeForm(data)
-      return yield* client.updateAlgorithm({ payload: formData })
-    })
+    Effect.gen(function* () {
+      const formData = yield* encodeForm(data);
+      return yield* client.updateAlgorithm({ payload: formData });
+    });
 
-  const userId = yield* Config.integer("GRAZE_USER_ID")
-  const getFeeds = () => client.getFeeds({ payload: { user_id: userId } })
+  const userId = yield* Config.int("GRAZE_USER_ID");
+  const getFeeds = () => client.getFeeds({ query: { user_id: userId } });
 
   return {
     ...client,
     updateAlgorithm,
-    getFeeds
-  }
-})
+    getFeeds,
+  };
+});
 
-export class GrazeClient extends Effect.Service<GrazeClient>()("GrazeClient", {
-  effect: grazeLive,
-  dependencies: [FetchHttpClient.layer]
-}) {
-  // TODO: test service
+export class GrazeClient extends Context.Service<
+  GrazeClient,
+  Effect.Success<typeof grazeLive>
+>()("GrazeClient") {
+  static readonly layer = Layer.effect(GrazeClient, grazeLive).pipe(
+    Layer.provide(FetchHttpClient.layer),
+  );
 }
 
+/** The resolved service shape (v4 has no `.Service` namespace on the tag). */
+export type GrazeClientService = Effect.Success<typeof grazeLive>;
+
 export class GrazeError extends Data.TaggedError("GrazeError")<{
-  message: string
-  status: number
-  statusText: string
-  json: unknown
+  message: string;
+  status: number;
+  statusText: string;
+  json: unknown;
 }> {}

package/src/builder.ts

@@ -11,144 +11,148 @@ import type {
   RegexNegationMatches,
   SocialGraph,
   TextMatchesAny,
-  TextMatchesNone
-} from "./schema/index.js"
+  TextMatchesNone,
+} from "./schema/index.js";
 
 const neverMatch: Filter = {
-  or: []
-}
+  or: [],
+};
 
 const and = (...filters: Array<Filter | null>): Filter => {
-  const flatFilters: Array<Filter> = []
+  const flatFilters: Array<Filter> = [];
   filters.forEach((f) => {
     if (f === null) {
       // if the filter is null, we never want to match this block.
-      flatFilters.push(neverMatch)
+      flatFilters.push(neverMatch);
     } else if ("and" in f) {
       // Automatically flatten nested ands.
-      flatFilters.push(...f.and)
+      flatFilters.push(...f.and);
     } else {
-      flatFilters.push(f)
+      flatFilters.push(f);
     }
-  })
-  return { and: flatFilters }
-}
+  });
+  return { and: flatFilters };
+};
 const or = (...filters: Array<Filter | null>): Filter => {
-  const flatFilters: Array<Filter> = []
+  const flatFilters: Array<Filter> = [];
   filters
     .filter((f) => f !== null)
     .forEach((f) => {
       if ("or" in f) {
-        flatFilters.push(...f.or)
+        flatFilters.push(...f.or);
       } else {
-        flatFilters.push(f)
+        flatFilters.push(f);
       }
-    })
-  return { or: flatFilters }
-}
+    });
+  return { or: flatFilters };
+};
 
 const regexMatches = (
   attribute: RegexMatches["regex_matches"][0],
-  regex: string
+  regex: string,
 ): RegexMatches => ({
-  regex_matches: [attribute, regex, true]
-})
+  regex_matches: [attribute, regex, true],
+});
 
 const regexNegationMatches = (
   attribute: RegexNegationMatches["regex_negation_matches"][0],
-  regex: string
+  regex: string,
 ): RegexNegationMatches => ({
-  regex_negation_matches: [attribute, regex, true]
-})
+  regex_negation_matches: [attribute, regex, true],
+});
 
 const textMatchesAny = ({
   attribute,
   caseInsensitive = true,
   patterns,
-  useRegex = false
+  useRegex = false,
 }: {
-  attribute: AttributeName
-  patterns: Array<string>
-  caseInsensitive?: boolean
-  useRegex?: boolean
+  attribute: AttributeName;
+  patterns: Array<string>;
+  caseInsensitive?: boolean;
+  useRegex?: boolean;
 }): TextMatchesAny => ({
-  regex_any: [attribute, patterns, caseInsensitive, useRegex]
-})
+  regex_any: [attribute, patterns, caseInsensitive, useRegex],
+});
 
 const textMatchesNone = ({
   attribute,
   caseInsensitive = true,
   patterns,
-  useRegex = false
+  useRegex = false,
 }: {
-  attribute: AttributeName
-  patterns: Array<string>
-  caseInsensitive?: boolean
-  useRegex?: boolean
+  attribute: AttributeName;
+  patterns: Array<string>;
+  caseInsensitive?: boolean;
+  useRegex?: boolean;
 }): TextMatchesNone => ({
-  regex_none: [attribute, patterns, caseInsensitive, useRegex]
-})
+  regex_none: [attribute, patterns, caseInsensitive, useRegex],
+});
 
 const isListMember = (uri: string): ListMemberFilter => ({
-  list_member: [uri, "in"]
-})
+  list_member: [uri, "in"],
+});
 const isNotListMember = (uri: string): ListMemberFilter => ({
-  list_member: [uri, "not_in"]
-})
+  list_member: [uri, "not_in"],
+});
 const socialGraph = (
   identifier: string,
   op: SocialGraph["social_graph"][1],
-  relation: SocialGraph["social_graph"][2]
+  relation: SocialGraph["social_graph"][2],
 ): SocialGraph => ({
-  social_graph: [identifier, op, relation]
-})
-const posterIsFollowedBy = (identifier: string) => socialGraph(identifier, "in", "followers")
-const posterFollows = (identifier: string) => socialGraph(identifier, "in", "follows")
-const posterIsNotFollowedBy = (identifier: string) => socialGraph(identifier, "not_in", "followers")
-const posterDoesNotFollow = (identifier: string) => socialGraph(identifier, "not_in", "follows")
+  social_graph: [identifier, op, relation],
+});
+const posterIsFollowedBy = (identifier: string) =>
+  socialGraph(identifier, "in", "followers");
+const posterFollows = (identifier: string) =>
+  socialGraph(identifier, "in", "follows");
+const posterIsNotFollowedBy = (identifier: string) =>
+  socialGraph(identifier, "not_in", "followers");
+const posterDoesNotFollow = (identifier: string) =>
+  socialGraph(identifier, "not_in", "follows");
 
 const embedContains = (type: EmbedType["embed_type"][1]): Filter => ({
-  embed_type: ["==", type]
-})
+  embed_type: ["==", type],
+});
 const embedDoesNotContain = (type: EmbedType["embed_type"][1]): Filter => ({
-  embed_type: ["!=", type]
-})
+  embed_type: ["!=", type],
+});
 
 const postTypeIs = (...types: PostTypeFilter["post_type"][1]): Filter => ({
-  post_type: ["in", types]
-})
+  post_type: ["in", types],
+});
 const postTypeIsNot = (...types: PostTypeFilter["post_type"][1]): Filter => ({
-  post_type: ["not_in", types]
-})
+  post_type: ["not_in", types],
+});
 
-const hasVideo: Filter = embedContains("video")
+const hasVideo: Filter = embedContains("video");
 
 const hasNoNSFWLabels: Filter = {
-  entity_excludes: ["labels", ["porn", "sexual", "nudity"]]
-}
+  entity_excludes: ["labels", ["porn", "sexual", "nudity"]],
+};
 const attributeCompare = (
   attr: AttributeName,
   op: AttributeComparison,
-  value: AttributeValue
+  value: AttributeValue,
 ): Filter => ({
-  attribute_compare: [attr, op, value]
-})
+  attribute_compare: [attr, op, value],
+});
 
-const isPost: Filter = postTypeIsNot("reply", "quote")
-const isReply: Filter = postTypeIs("reply")
-const isQuote: Filter = postTypeIs("quote")
-const isNotReply: Filter = postTypeIsNot("reply")
-const isNotQuote: Filter = postTypeIsNot("quote")
+const isPost: Filter = postTypeIsNot("reply", "quote");
+const isReply: Filter = postTypeIs("reply");
+const isQuote: Filter = postTypeIs("quote");
+const isNotReply: Filter = postTypeIsNot("reply");
+const isNotQuote: Filter = postTypeIsNot("quote");
 
 const isContentOk = (threshold: number = 0.9): ContentModerationBlock => ({
-  content_moderation: ["OK", ">=", threshold]
-})
+  content_moderation: ["OK", ">=", threshold],
+});
 
 export const Algo = {
   filter: (...filters: Array<Filter>): { filter: Filter } => ({
-    filter: and(...filters)
-  })
-}
+    filter: and(...filters),
+  }),
+};
 
 export const F = {
   and,
@@ -176,5 +180,5 @@ export const F = {
   isNotQuote,
   isContentOk,
   embedContains,
-  embedDoesNotContain
-}
+  embedDoesNotContain,
+};

package/src/common.ts

@@ -1,11 +1,6 @@
-import { HttpApiSchema } from "@effect/platform"
-import { Schema } from "effect"
+import { Schema } from "effect";
 
-export const UserIdParam = HttpApiSchema.param(
-  "userId",
-  Schema.NumberFromString
-)
-export const FeedIdParam = HttpApiSchema.param(
-  "feedId",
-  Schema.NumberFromString
-)
+// v4 has no `HttpApiSchema.param`: path params are declared inline in the
+// endpoint path (`:feedId`) with a `params: { feedId: FeedIdParam }` schema map.
+export const UserIdParam = Schema.NumberFromString;
+export const FeedIdParam = Schema.NumberFromString;

package/src/index.ts

@@ -1,85 +1,94 @@
-import { ConfigProvider, Effect, Layer } from "effect"
-import { GrazeClient } from "./GrazeClient.js"
+import { ConfigProvider, Effect } from "effect";
+import { GrazeClient, type GrazeClientService } from "./GrazeClient.js";
 
 type Promisify<T> = T extends (
   ...args: Array<any>
-) => Effect.Effect<infer A, infer _E, never> ? (...args: Parameters<T>) => Promise<A>
-  : never
+) => Effect.Effect<infer A, infer _E, never>
+  ? (...args: Parameters<T>) => Promise<A>
+  : never;
 
 export class GrazeService {
-  getFeed: Promisify<typeof GrazeClient.Service.getFeed>
-  getFeeds: Promisify<typeof GrazeClient.Service.getFeeds>
-  hidePost: Promisify<typeof GrazeClient.Service.hidePost>
-  unhidePost: Promisify<typeof GrazeClient.Service.unhidePost>
-  updateAlgorithm: Promisify<typeof GrazeClient.Service.updateAlgorithm>
-  publishAlgorithm: Promisify<typeof GrazeClient.Service.publishAlgorithm>
+  getFeed: Promisify<GrazeClientService["getFeed"]>;
+  getFeeds: Promisify<GrazeClientService["getFeeds"]>;
+  hidePost: Promisify<GrazeClientService["hidePost"]>;
+  unhidePost: Promisify<GrazeClientService["unhidePost"]>;
+  updateAlgorithm: Promisify<GrazeClientService["updateAlgorithm"]>;
+  publishAlgorithm: Promisify<GrazeClientService["publishAlgorithm"]>;
   stickyposts: {
-    get: Promisify<typeof GrazeClient.Service.stickyposts.get>
-    create: Promisify<typeof GrazeClient.Service.stickyposts.create>
-    delete: Promisify<typeof GrazeClient.Service.stickyposts.delete>
-    update: Promisify<typeof GrazeClient.Service.stickyposts.update>
-  }
+    get: Promisify<GrazeClientService["stickyposts"]["get"]>;
+    create: Promisify<GrazeClientService["stickyposts"]["create"]>;
+    delete: Promisify<GrazeClientService["stickyposts"]["delete"]>;
+    update: Promisify<GrazeClientService["stickyposts"]["update"]>;
+  };
 
   constructor({
     apiUrl,
     cookie,
-    userId
+    userId,
   }: {
-    apiUrl: string
-    cookie: string
-    userId: number
+    apiUrl: string;
+    cookie: string;
+    userId: number;
   }) {
     const envMap = new Map([
       ["GRAZE_API_URL", apiUrl],
       ["GRAZE_COOKIE", cookie],
-      ["GRAZE_USER_ID", userId.toString()]
-    ])
-    const provider = ConfigProvider.fromMap(envMap)
-    const layer = Layer.setConfigProvider(provider)
+      ["GRAZE_USER_ID", userId.toString()],
+    ]);
+    const provider = ConfigProvider.make((path) => {
+      const value = envMap.get(path.join("."));
+      return Effect.succeed(
+        value !== undefined ? ConfigProvider.makeValue(value) : undefined,
+      );
+    });
+    const layer = ConfigProvider.layer(provider);
     const make = setup.pipe(
-      Effect.provide(GrazeClient.Default),
-      Effect.provide(layer)
-    )
-    const api = Effect.runSync(make)
-    this.getFeed = api.getFeed
-    this.getFeeds = api.getFeeds
-    this.hidePost = api.hidePost
-    this.unhidePost = api.unhidePost
-    this.updateAlgorithm = api.updateAlgorithm
-    this.publishAlgorithm = api.publishAlgorithm
+      Effect.provide(GrazeClient.layer),
+      Effect.provide(layer),
+    );
+    const api = Effect.runSync(make);
+    this.getFeed = api.getFeed;
+    this.getFeeds = api.getFeeds;
+    this.hidePost = api.hidePost;
+    this.unhidePost = api.unhidePost;
+    this.updateAlgorithm = api.updateAlgorithm;
+    this.publishAlgorithm = api.publishAlgorithm;
     this.stickyposts = {
       get: api.getStickyPosts,
       create: api.createStickyPost,
       delete: api.deleteStickyPost,
-      update: api.updateStickyPost
-    }
+      update: api.updateStickyPost,
+    };
   }
 }
 
-const setup = Effect.gen(function*() {
-  const client = yield* GrazeClient
-  const getFeed = (...args: Parameters<typeof client.getFeed>) => client.getFeed(...args).pipe(Effect.runPromise)
-  const getFeeds = (...args: Parameters<typeof client.getFeeds>) => client.getFeeds(...args).pipe(Effect.runPromise)
-  const hidePost = (...args: Parameters<typeof client.hidePost>) => client.hidePost(...args).pipe(Effect.runPromise)
+const setup = Effect.gen(function* () {
+  const client = yield* GrazeClient;
+  const getFeed = (...args: Parameters<typeof client.getFeed>) =>
+    client.getFeed(...args).pipe(Effect.runPromise);
+  const getFeeds = (...args: Parameters<typeof client.getFeeds>) =>
+    client.getFeeds(...args).pipe(Effect.runPromise);
+  const hidePost = (...args: Parameters<typeof client.hidePost>) =>
+    client.hidePost(...args).pipe(Effect.runPromise);
   const unhidePost = (...args: Parameters<typeof client.unhidePost>) =>
-    client.unhidePost(...args).pipe(Effect.runPromise)
+    client.unhidePost(...args).pipe(Effect.runPromise);
   const updateAlgorithm = (
     ...args: Parameters<typeof client.updateAlgorithm>
-  ) => client.updateAlgorithm(...args).pipe(Effect.runPromise)
+  ) => client.updateAlgorithm(...args).pipe(Effect.runPromise);
   const publishAlgorithm = (
     ...args: Parameters<typeof client.publishAlgorithm>
-  ) => client.publishAlgorithm(...args).pipe(Effect.runPromise)
+  ) => client.publishAlgorithm(...args).pipe(Effect.runPromise);
   const getStickyPosts = (...args: Parameters<typeof client.stickyposts.get>) =>
-    client.stickyposts.get(...args).pipe(Effect.runPromise)
+    client.stickyposts.get(...args).pipe(Effect.runPromise);
   const createStickyPost = (
     ...args: Parameters<typeof client.stickyposts.create>
-  ) => client.stickyposts.create(...args).pipe(Effect.runPromise)
+  ) => client.stickyposts.create(...args).pipe(Effect.runPromise);
   const deleteStickyPost = (
     ...args: Parameters<typeof client.stickyposts.delete>
-  ) => client.stickyposts.delete(...args).pipe(Effect.runPromise)
+  ) => client.stickyposts.delete(...args).pipe(Effect.runPromise);
   const updateStickyPost = (
     ...args: Parameters<typeof client.stickyposts.update>
-  ) => client.stickyposts.update(...args).pipe(Effect.runPromise)
+  ) => client.stickyposts.update(...args).pipe(Effect.runPromise);
 
   return {
     getFeed,
@@ -91,9 +100,9 @@ const setup = Effect.gen(function*() {
     getStickyPosts,
     createStickyPost,
     deleteStickyPost,
-    updateStickyPost
-  }
-})
+    updateStickyPost,
+  };
+});
 
-export { Algo, F } from "./builder.js"
-export * from "./schema/index.js"
+export { Algo, F } from "./builder.js";
+export * from "./schema/index.js";

package/src/schema/Post.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from "effect"
+import { Schema as S } from "effect";
 
 /**
  * Schema for Bluesky objects
@@ -12,24 +12,24 @@ export const Author = S.Struct({
   labels: S.Array(S.Any),
   viewer: S.Any,
   createdAt: S.String,
-  associated: S.Union(S.Null, S.Any),
-  displayName: S.String
-})
-export type Author = typeof Author.Type
+  associated: S.Union([S.Null, S.Any]),
+  displayName: S.String,
+});
+export type Author = typeof Author.Type;
 
 export const Record = S.Struct({
-  tags: S.Union(S.Null, S.Any),
+  tags: S.Union([S.Null, S.Any]),
   text: S.String,
   $type: S.String,
   embed: S.Any,
   langs: S.NullOr(S.Array(S.String)),
-  reply: S.Union(S.Null, S.Any),
+  reply: S.Union([S.Null, S.Any]),
   facets: S.NullOr(S.Array(S.Any)),
-  labels: S.Union(S.Null, S.Any),
-  entities: S.Union(S.Null, S.Any),
-  createdAt: S.String
-})
-export type Record = typeof Record.Type
+  labels: S.Union([S.Null, S.Any]),
+  entities: S.Union([S.Null, S.Any]),
+  createdAt: S.String,
+});
+export type Record = typeof Record.Type;
 
 export const Post = S.Struct({
   cid: S.String,
@@ -44,7 +44,7 @@ export const Post = S.Struct({
   likeCount: S.Number,
   quoteCount: S.Number,
   replyCount: S.Number,
-  threadgate: S.Union(S.Null, S.Unknown),
-  repostCount: S.Number
-})
-export type Post = typeof Post.Type
+  threadgate: S.Union([S.Null, S.Unknown]),
+  repostCount: S.Number,
+});
+export type Post = typeof Post.Type;