graze-client 0.1.0

package/.changeset/config.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.2/schema.json",
+  "changelog": [
+    "@changesets/changelog-github",
+    {
+      "repo": "<PLACEHOLDER>"
+    }
+  ],
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.github/actions/setup/action.yml

@@ -0,0 +1,21 @@
+name: Setup
+description: Perform standard setup and install dependencies using pnpm.
+inputs:
+  node-version:
+    description: The version of Node.js to install
+    required: true
+    default: 20.16.0
+
+runs:
+  using: composite
+  steps:
+    - name: Install pnpm
+      uses: pnpm/action-setup@v3
+    - name: Install node
+      uses: actions/setup-node@v4
+      with:
+        cache: pnpm
+        node-version: ${{ inputs.node-version }}
+    - name: Install dependencies
+      shell: bash
+      run: pnpm install

package/.github/workflows/check.yml

@@ -0,0 +1,57 @@
+name: Check
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - run: pnpm codegen
+      - name: Check source state
+        run: git add packages/*/src && git diff-index --cached HEAD --exit-code packages/*/src
+
+  types:
+    name: Types
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - run: pnpm check
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - run: pnpm lint
+
+  test:
+    name: Test 
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - run: pnpm test

package/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+
+permissions: {}
+
+jobs:
+  release:
+    if: github.repository_owner == 'Effect-Ts'
+    name: Release
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: write
+      id-token: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - name: Create Release Pull Request or Publish
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          version: pnpm changeset-version
+          publish: pnpm changeset-publish
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/snapshot.yml

@@ -0,0 +1,24 @@
+name: Snapshot
+
+on:
+  pull_request:
+    branches: [main, next-minor, next-major]
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  snapshot:
+    name: Snapshot
+    if: github.repository_owner == 'Effect-Ts'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        uses: ./.github/actions/setup
+      - name: Build package
+        run: pnpm build
+      - name: Create snapshot
+        id: snapshot
+        run: pnpx pkg-pr-new@0.0.24 publish --pnpm --comment=off

package/.vscode/effect.code-snippets

@@ -0,0 +1,72 @@
+{
+	// Place your cadence workspace snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and 
+	// description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope 
+	// is left empty or omitted, the snippet gets applied to all languages. The prefix is what is 
+	// used to trigger the snippet and the body will be expanded and inserted. Possible variables are: 
+	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. 
+	// Placeholders with the same ids are connected.
+	// Example:
+	// "Print to console": {
+	// 	"scope": "javascript,typescript",
+	// 	"prefix": "log",
+	// 	"body": [
+	// 		"console.log('$1');",
+	// 		"$2"
+	// 	],
+	// 	"description": "Log output to console"
+	// }
+	"Gen Function $": {
+		"prefix": "gg",
+		"body": [
+			"function* () {\n\t$0\n}"
+		],
+		"description": "Generator function"
+	},
+	"Gen Function $ (wrapped)": {
+		"prefix": "egg",
+		"body": [
+			"Effect.gen(function* () {\n\t$0\n})"
+		],
+		"description": "Generator function"
+	},
+	"Gen Yield $": {
+		"prefix": "yy",
+		"body": [
+			"yield* $0"
+		],
+		"description": "Yield generator"
+	},
+	"Gen Yield $ (const)": {
+		"prefix": "cyy",
+		"body": [
+			"const $1 = yield* $0"
+		],
+		"description": "Yield generator constant"
+	},
+	"Tagged Class $": {
+		"prefix": "etc",
+		"body": [
+			"export class $1 extends Context.Tag(\"$1\")<$1,I$1> (){",
+			"}"
+		]
+	},
+	"Tagged Error $": {
+		"prefix": "ete",
+		"body": [
+			"export class $1 extends Data.TaggedError(\"$1\")<{",
+			"\tmessage: string",
+			"\tcause?: unknown",
+			"}> {}"
+		]
+	},
+	"Effect Service $": {
+		"prefix": "effs",
+		"body": [
+			"export class $1 extends Effect.Service<$1>()(\"$1\", {",
+			"\teffect: Effect.gen(function* () {",
+			"\t\t$0",
+			"\t}),",
+			"}) {}"
+		]
+	},
+}

package/.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+  "recommendations": [
+      "effectful-tech.effect-vscode",
+      "dbaeumer.vscode-eslint"
+    ]
+}

package/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true,
+}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# graze-client
+
+## 0.1.0
+
+### Minor Changes
+
+- Initialize GrazeClient

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present <PLACEHOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# Graze Client
+
+This is a simple Typescript package for interacting with the [Graze](https://graze.social/) API. The API is undocumented and not officially supported, but this package was made with their blessing.
+
+It is a bit hastily put together and under development (not all APIs are implemented), but it works.
+
+There are two exports:
+
+### 1. A promise-based `GrazeService`
+
+```ts
+import { GrazeService } from "graze-client";
+
+const graze = new GrazeService({
+  apiUrl: "https://api.graze.social",
+  cookie: "my-graze-cookie",
+  userId: 15,
+});
+
+const myFeeds = await graze.getFeeds();
+const feed = await graze.getFeed({ path: { feedId: 1234 } });
+// hide a post
+await graze.hidePost({
+  payload: { algo_id: 1234, at_uri: "at://<did>/app.bsky.feed.post/<rkey>" },
+});
+// update an algorithm
+const hasVideo: Form.Filter = {
+  embed_type: ["==", "video"],
+};
+const hasKeyword: Form.Filter = {
+  regex_matches: ["text", /Hello World!/.source, true],
+};
+const res = await graze.updateAlgorithm({
+  record_name: "my-feed",
+  display_name: "My Feed",
+  user_id: 1,
+  order: "new",
+  id: 1234,
+  algorithm_manifest: {
+    filter: { and: [hasVideo, hasKeyword] },
+  },
+});
+
+// publish the algorithm
+const res = await graze.publishAlgorithm({ path: { feedId: 1234 } });
+```
+
+### 2. An [Effect](https://effect.website/) based `GrazeClient`
+
+This package is build with [Effect](https://effect.website/). One feature of Effect is the ability to generate typesafe API clients with input/output validation. The `GrazeClient` is an Effect service for performing API requests. A benefit of using Effect is that errors will be typed in addition to success cases.
+
+In the below example, the `updateAlgo` effect has the type: `Effect.Effect<void, HttpApiDecodeError | HttpClientError | ParseError, GrazeClient>`, meaning the success value is `void`, the possible errors are `HttpApiDecodeError | HttpClientError | ParseError`, and the effect requires a `GrazeClient` to run.
+
+```ts
+const updateAlgo = Effect.gen(function* () {
+  const client = yield* GrazeClient;
+
+  const res = yield* client.updateAlgorithm({
+    record_name: "my-feed",
+    display_name: "My Feed",
+    user_id: 1,
+    order: "new",
+    id: 1234,
+    algorithm_manifest: {
+      filter: {
+        and: [
+          {
+            regex_matches: ["text", /Hello World!/.source, true],
+          },
+        ],
+      },
+    },
+  });
+});
+```
+
+If you're interested, I recommend reading more in the [Effect](https://effect.website/) docs.
+
+# To do
+
+- [ ] Organize schema to provide more useful type exports
+- [ ] Add additional filter blocks to `UpdateAlgorithmPayload` schema.
+- [ ] Add API to create a feed.

package/eslint.config.mjs

@@ -0,0 +1,120 @@
+import { fixupPluginRules } from "@eslint/compat"
+import { FlatCompat } from "@eslint/eslintrc"
+import js from "@eslint/js"
+import tsParser from "@typescript-eslint/parser"
+import codegen from "eslint-plugin-codegen"
+import _import from "eslint-plugin-import"
+import simpleImportSort from "eslint-plugin-simple-import-sort"
+import sortDestructureKeys from "eslint-plugin-sort-destructure-keys"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all
+})
+
+export default [
+  {
+    ignores: ["**/dist", "**/build", "**/docs", "**/*.md"]
+  },
+  ...compat.extends(
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:@effect/recommended"
+  ),
+  {
+    plugins: {
+      import: fixupPluginRules(_import),
+      "sort-destructure-keys": sortDestructureKeys,
+      "simple-import-sort": simpleImportSort,
+      codegen
+    },
+
+    languageOptions: {
+      parser: tsParser,
+      ecmaVersion: 2018,
+      sourceType: "module"
+    },
+
+    settings: {
+      "import/parsers": {
+        "@typescript-eslint/parser": [".ts", ".tsx"]
+      },
+
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true
+        }
+      }
+    },
+
+    rules: {
+      "codegen/codegen": "error",
+      "no-fallthrough": "off",
+      "no-irregular-whitespace": "off",
+      "object-shorthand": "error",
+      "prefer-destructuring": "off",
+      "sort-imports": "off",
+
+      "no-restricted-syntax": ["error", {
+        selector: "CallExpression[callee.property.name='push'] > SpreadElement.arguments",
+        message: "Do not use spread arguments in Array.push"
+      }],
+
+      "no-unused-vars": "off",
+      "prefer-rest-params": "off",
+      "prefer-spread": "off",
+      "import/first": "error",
+      "import/newline-after-import": "error",
+      "import/no-duplicates": "error",
+      "import/no-unresolved": "off",
+      "import/order": "off",
+      "simple-import-sort/imports": "off",
+      "sort-destructure-keys/sort-destructure-keys": "error",
+      "deprecation/deprecation": "off",
+
+      "@typescript-eslint/array-type": ["warn", {
+        default: "generic",
+        readonly: "generic"
+      }],
+
+      "@typescript-eslint/member-delimiter-style": 0,
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/ban-types": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-empty-interface": "off",
+      "@typescript-eslint/consistent-type-imports": "warn",
+
+      "@typescript-eslint/no-unused-vars": ["error", {
+        argsIgnorePattern: "^_",
+        varsIgnorePattern: "^_"
+      }],
+
+      "@typescript-eslint/ban-ts-comment": "off",
+      "@typescript-eslint/camelcase": "off",
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/interface-name-prefix": "off",
+      "@typescript-eslint/no-array-constructor": "off",
+      "@typescript-eslint/no-use-before-define": "off",
+      "@typescript-eslint/no-namespace": "off",
+
+      "@effect/dprint": ["error", {
+        config: {
+          indentWidth: 2,
+          lineWidth: 120,
+          semiColons: "asi",
+          quoteStyle: "alwaysDouble",
+          trailingCommas: "never",
+          operatorPosition: "maintain",
+          "arrowFunction.useParentheses": "force"
+        }
+      }]
+    }
+  }
+]

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "graze-client",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "A basic Effect package",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kristojorg/graze-client"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "."
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./effect": {
+      "types": "./dist/dts/GrazeClient.d.ts",
+      "import": "./dist/esm/GrazeClient.js",
+      "default": "./dist/cjs/GrazeClient.js"
+    },
+    "./schema": {
+      "types": "./dist/dts/schema/index.d.ts",
+      "import": "./dist/esm/schema/index.js",
+      "default": "./dist/cjs/schema/index.js"
+    }
+  },
+  "scripts": {
+    "codegen": "build-utils prepare-v2",
+    "build": "bun build-esm && bun build-annotate && bun build-cjs && build-utils pack-v2",
+    "build-esm": "tsc -b tsconfig.build.json",
+    "build-cjs": "babel build/esm --plugins @babel/transform-export-namespace-from --plugins @babel/transform-modules-commonjs --out-dir build/cjs --source-maps",
+    "build-annotate": "babel build/esm --plugins annotate-pure-calls --out-dir build/esm --source-maps",
+    "check": "tsc -b tsconfig.json",
+    "lint": "eslint \"**/{src,test,examples,scripts,dtslint}/**/*.{ts,mjs}\"",
+    "lint-fix": "bun lint --fix",
+    "test": "vitest",
+    "coverage": "vitest --coverage",
+    "changeset-version": "changeset version",
+    "changeset-publish": "bun build && TEST_DIST= bun vitest && changeset publish"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.75.1",
+    "effect": "latest"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-export-namespace-from": "^7.24.7",
+    "@babel/plugin-transform-modules-commonjs": "^7.24.8",
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.27.8",
+    "@effect/build-utils": "^0.7.7",
+    "@effect/eslint-plugin": "^0.2.0",
+    "@effect/language-service": "^0.1.0",
+    "@effect/vitest": "latest",
+    "@eslint/compat": "1.1.1",
+    "@eslint/eslintrc": "3.1.0",
+    "@eslint/js": "9.10.0",
+    "@types/node": "^22.5.2",
+    "@typescript-eslint/eslint-plugin": "^8.4.0",
+    "@typescript-eslint/parser": "^8.4.0",
+    "babel-plugin-annotate-pure-calls": "^0.4.0",
+    "eslint": "^9.10.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-codegen": "^0.28.0",
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-sort-destructure-keys": "^2.0.0",
+    "tsx": "^4.17.0",
+    "typescript": "^5.6.2",
+    "vitest": "^2.0.5"
+  },
+  "effect": {
+    "generateExports": {
+      "include": [
+        "**/*.ts"
+      ]
+    },
+    "generateIndex": {
+      "include": [
+        "**/*.ts"
+      ]
+    }
+  },
+  "patchedDependencies": {
+    "@changesets/get-github-info@0.6.0": "patches/@changesets__get-github-info@0.6.0.patch",
+    "babel-plugin-annotate-pure-calls@0.4.0": "patches/babel-plugin-annotate-pure-calls@0.4.0.patch"
+  }
+}

package/patches/@changesets__get-github-info@0.6.0.patch

@@ -0,0 +1,48 @@
+diff --git a/dist/changesets-get-github-info.cjs.js b/dist/changesets-get-github-info.cjs.js
+index a74df59f8a5988f458a3476087399f5e6dfe4818..ce5e60ef9916eb0cb76ab1e9dd422abcad752bf6 100644
+--- a/dist/changesets-get-github-info.cjs.js
++++ b/dist/changesets-get-github-info.cjs.js
+@@ -251,18 +251,13 @@ async function getInfo(request) {
+     b = new Date(b.mergedAt);
+     return a > b ? 1 : a < b ? -1 : 0;
+   })[0] : null;
+-
+-  if (associatedPullRequest) {
+-    user = associatedPullRequest.author;
+-  }
+-
+   return {
+     user: user ? user.login : null,
+     pull: associatedPullRequest ? associatedPullRequest.number : null,
+     links: {
+       commit: `[\`${request.commit.slice(0, 7)}\`](${data.commitUrl})`,
+       pull: associatedPullRequest ? `[#${associatedPullRequest.number}](${associatedPullRequest.url})` : null,
+-      user: user ? `[@${user.login}](${user.url})` : null
++      user: user ? `@${user.login}` : null
+     }
+   };
+ }
+diff --git a/dist/changesets-get-github-info.esm.js b/dist/changesets-get-github-info.esm.js
+index 27e5c972ab1202ff16f5124b471f4bbcc46be2b5..3940a8fe86e10cb46d8ff6436dea1103b1839927 100644
+--- a/dist/changesets-get-github-info.esm.js
++++ b/dist/changesets-get-github-info.esm.js
+@@ -242,18 +242,13 @@ async function getInfo(request) {
+     b = new Date(b.mergedAt);
+     return a > b ? 1 : a < b ? -1 : 0;
+   })[0] : null;
+-
+-  if (associatedPullRequest) {
+-    user = associatedPullRequest.author;
+-  }
+-
+   return {
+     user: user ? user.login : null,
+     pull: associatedPullRequest ? associatedPullRequest.number : null,
+     links: {
+       commit: `[\`${request.commit.slice(0, 7)}\`](${data.commitUrl})`,
+       pull: associatedPullRequest ? `[#${associatedPullRequest.number}](${associatedPullRequest.url})` : null,
+-      user: user ? `[@${user.login}](${user.url})` : null
++      user: user ? `@${user.login}` : null
+     }
+   };
+ }

package/patches/babel-plugin-annotate-pure-calls@0.4.0.patch

@@ -0,0 +1,13 @@
+diff --git a/lib/index.js b/lib/index.js
+index 2182884e21874ebb37261e2375eec08ad956fc9a..ef5630199121c2830756e00c7cc48cf1078c8207 100644
+--- a/lib/index.js
++++ b/lib/index.js
+@@ -78,7 +78,7 @@ const isInAssignmentContext = path => {
+ 
+     parentPath = _ref.parentPath;
+ 
+-    if (parentPath.isVariableDeclaration() || parentPath.isAssignmentExpression()) {
++    if (parentPath.isVariableDeclaration() || parentPath.isAssignmentExpression() || parentPath.isClassDeclaration()) {
+       return true;
+     }
+   } while (parentPath !== statement);

package/scratchpad/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "declaration": false,
+    "declarationMap": false,
+    "composite": false,
+    "incremental": false
+  }
+}

package/setupTests.ts

@@ -0,0 +1,3 @@
+import * as it from "@effect/vitest"
+
+it.addEqualityTesters()

package/src/GrazeClient.ts

@@ -0,0 +1,121 @@
+import {
+  AlgoUpdateResponse,
+  GetAlgoResponse,
+  GetAlgorithmsResponse,
+  HidePostBody,
+} from "./schema/shared.js";
+import {
+  FetchHttpClient,
+  HttpApi,
+  HttpApiClient,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApiSchema,
+  HttpClient,
+  HttpClientRequest,
+} from "@effect/platform";
+import { Config, Data, Effect, Redacted, Schema } from "effect";
+
+import * as Form from "./schema/UpdateAlgorithmPayload.js";
+
+function isStringOrBlob(val: unknown): val is string | 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();
+    for (const key in encoded) {
+      if (encoded.hasOwnProperty(key)) {
+        const val = encoded[key as keyof Form.FullForm];
+        if (isStringOrBlob(val)) {
+          formData.append(key, val);
+        }
+      }
+    }
+    return formData;
+  });
+
+const UserIdParam = HttpApiSchema.param("userId", Schema.NumberFromString);
+const FeedIdParam = HttpApiSchema.param("feedId", Schema.NumberFromString);
+
+const GrazeApiGroup = HttpApiGroup.make("graze", { topLevel: true })
+  .add(
+    HttpApiEndpoint.get("getFeeds")`/app/my_feeds`
+      .addSuccess(GetAlgorithmsResponse)
+      .setPayload(
+        Schema.Struct({
+          user_id: UserIdParam,
+        })
+      )
+  )
+  .add(
+    HttpApiEndpoint.get("getFeed")`/app/my_feeds/${FeedIdParam}`.addSuccess(
+      GetAlgoResponse
+    )
+  )
+  .add(
+    HttpApiEndpoint.post("updateAlgorithm")`/app/edit_algo_image`
+      .setPayload(HttpApiSchema.Multipart(Form.FullForm))
+      .addSuccess(AlgoUpdateResponse)
+  )
+  .add(
+    HttpApiEndpoint.get(
+      "publishAlgorithm"
+    )`/app/publish_algo/${FeedIdParam}`.addSuccess(Schema.Unknown)
+  )
+  .add(
+    HttpApiEndpoint.post("hidePost")`/app/hide_post`
+      .setPayload(HidePostBody)
+      .addSuccess(Schema.Unknown)
+  );
+
+class GrazeApiDef extends HttpApi.make("grazeApi").add(GrazeApiGroup) {}
+
+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(),
+    transformClient: (client) =>
+      client.pipe(
+        HttpClient.filterStatusOk,
+        HttpClient.mapRequest(
+          HttpClientRequest.setHeaders({
+            cookie: Redacted.value(cookie),
+          })
+        )
+      ),
+  });
+
+  const updateAlgorithm = (data: Form.FullForm) =>
+    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 } });
+
+  return {
+    ...client,
+    updateAlgorithm,
+    getFeeds,
+  };
+});
+
+export class GrazeClient extends Effect.Service<GrazeClient>()("GrazeClient", {
+  effect: grazeLive,
+  dependencies: [FetchHttpClient.layer],
+}) {
+  // TODO: test service
+}
+
+export class GrazeError extends Data.TaggedError("GrazeError")<{
+  message: string;
+  status: number;
+  statusText: string;
+  json: unknown;
+}> {}

package/src/index.ts

@@ -0,0 +1,68 @@
+import { ConfigProvider, Effect, Layer } from "effect";
+import { GrazeClient } from "src/GrazeClient.js";
+
+type Promisify<T> = T extends (
+  ...args: any[]
+) => 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>;
+  updateAlgorithm: Promisify<typeof GrazeClient.Service.updateAlgorithm>;
+  publishAlgorithm: Promisify<typeof GrazeClient.Service.publishAlgorithm>;
+
+  constructor({
+    apiUrl,
+    cookie,
+    userId,
+  }: {
+    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);
+    const make = setup.pipe(
+      Effect.provide(layer),
+      Effect.provide(GrazeClient.Default)
+    );
+    const api = Effect.runSync(make);
+    this.getFeed = api.getFeed;
+    this.getFeeds = api.getFeeds;
+    this.hidePost = api.hidePost;
+    this.updateAlgorithm = api.updateAlgorithm;
+    this.publishAlgorithm = api.publishAlgorithm;
+  }
+}
+
+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 updateAlgorithm = (
+    ...args: Parameters<typeof client.updateAlgorithm>
+  ) => client.updateAlgorithm(...args).pipe(Effect.runPromise);
+  const publishAlgorithm = (
+    ...args: Parameters<typeof client.publishAlgorithm>
+  ) => client.publishAlgorithm(...args).pipe(Effect.runPromise);
+
+  return {
+    getFeed,
+    getFeeds,
+    hidePost,
+    updateAlgorithm,
+    publishAlgorithm,
+  };
+});

package/src/schema/UpdateAlgorithmPayload.ts

@@ -0,0 +1,220 @@
+import { Schema as S } from "effect";
+
+// ------------------- Primitives ---------------------------------
+
+export const ListUri = S.String;
+export type ListUri = typeof ListUri.Type;
+
+export const AttributeName = S.Union(
+  S.Literal("text"),
+  S.Literal("reply"),
+  S.Literal("embed.images[*].alt"),
+  S.Literal("embed.alt"),
+  S.Literal("embed"),
+  S.Literal("embed.external.uri"),
+  S.Literal("embed.external.title"),
+  S.Literal("embed.external.description")
+);
+export type AttributeName = typeof AttributeName.Type;
+export const AttributeComparison = S.Literal("==");
+export type AttributeComparison = typeof AttributeComparison.Type;
+export const AttributeValue = S.Null;
+export type AttributeValue = typeof AttributeValue.Type;
+
+// ------------------- Filters ------------------------------------
+
+export type Filter =
+  | And
+  | Or
+  | ListMemberFilter
+  | AttributeCompare
+  | RegexMatches
+  | RegexNegationMatches
+  | ContentModerationBlock
+  | EntityExcludesLabels
+  | EmbedType;
+
+export type And = Readonly<{ and: ReadonlyArray<Filter> }>;
+export type Or = Readonly<{ or: ReadonlyArray<Filter> }>;
+export type ListMemberFilter = Readonly<{
+  list_member: readonly [ListUri, "in" | "not_in"];
+}>;
+export type AttributeCompare = Readonly<{
+  attribute_compare: readonly [
+    AttributeName,
+    AttributeComparison,
+    AttributeValue
+  ];
+}>;
+export type RegexMatches = Readonly<{
+  regex_matches: readonly [AttributeName, string, boolean];
+}>;
+export type RegexNegationMatches = Readonly<{
+  regex_negation_matches: readonly [AttributeName, string, boolean];
+}>;
+export type ContentModerationBlock = Readonly<{
+  content_moderation: readonly ["OK", ">=", number];
+}>;
+export type EntityExcludesLabels = Readonly<{
+  entity_excludes: readonly ["labels", readonly ["porn", "sexual", "nudity"]];
+}>;
+export type EmbedType = Readonly<{
+  embed_type: readonly [
+    "==" | "!=",
+    "video" | "image" | "link" | "post" | "gif" | "image_group"
+  ];
+}>;
+
+export const Filter = S.Union(
+  S.suspend((): S.Schema<And> => And),
+  S.suspend((): S.Schema<Or> => Or),
+  S.suspend((): S.Schema<ListMemberFilter> => ListMemberFilter),
+  S.suspend((): S.Schema<AttributeCompare> => AttributeCompare),
+  S.suspend((): S.Schema<RegexMatches> => RegexMatches),
+  S.suspend((): S.Schema<RegexNegationMatches> => RegexNegationMatches),
+  S.suspend((): S.Schema<ContentModerationBlock> => ContentModerationBlock),
+  S.suspend((): S.Schema<EntityExcludesLabels> => EntityExcludesLabels),
+  S.suspend((): S.Schema<EmbedType> => EmbedType)
+);
+
+export const Or = S.Struct({ or: S.Array(Filter) });
+export const And = S.Struct({ and: S.Array(Filter) });
+export const ListMemberFilter = S.Struct({
+  list_member: S.Tuple(ListUri, S.Literal("in", "not_in")),
+});
+export const AttributeCompare = S.Struct({
+  attribute_compare: S.Tuple(
+    AttributeName,
+    AttributeComparison,
+    AttributeValue
+  ),
+});
+const RegexMatchBase = S.Tuple(
+  AttributeName,
+  S.String.annotations({
+    title: "Regex Pattern",
+    description: "The source of the regex pattern to match against.",
+  }),
+  S.Boolean.annotations({
+    title: "Case Insensitive?",
+    description: "True if the regex should be case insensitive.",
+  })
+);
+export const RegexMatches = S.Struct({
+  regex_matches: RegexMatchBase,
+});
+export const RegexNegationMatches = S.Struct({
+  regex_negation_matches: RegexMatchBase,
+});
+export const ContentModerationBlock = S.Struct({
+  content_moderation: S.Tuple(
+    S.Literal("OK"),
+    S.Literal(">="),
+    S.Number.annotations({
+      title: "Threshold",
+      description: "The threshold for content moderation.",
+    })
+  ),
+});
+export const EntityExcludesLabels = S.Struct({
+  entity_excludes: S.Tuple(
+    S.Literal("labels"),
+    S.Tuple(S.Literal("porn"), S.Literal("sexual"), S.Literal("nudity"))
+  ),
+});
+export const EmbedType = S.Struct({
+  embed_type: S.Tuple(
+    S.Literal("==", "!="),
+    S.Literal("video", "image", "link", "post", "gif", "image_group")
+  ),
+});
+
+// ---------------------- Sort Settings -----------------------------
+
+export const SortSettings = S.Struct({
+  time_window: S.Number,
+  decay_penalty: S.Number,
+  like_count_multiplier: S.Number,
+  reply_count_multiplier: S.Number,
+  repost_count_multiplier: S.Number,
+  reader_like_count_multiplier: S.Number,
+  reader_reply_count_multiplier: S.Number,
+  reader_repost_count_multiplier: S.Number,
+});
+export type SortSettings = typeof SortSettings.Type;
+
+// ---------------------- Form Data  ---------------------------------
+
+export const DisplayName = S.String.annotations({
+  description: "The public name of the feed.",
+});
+export type DisplayName = typeof DisplayName.Type;
+
+export const RecordName = S.String.annotations({
+  description: "The slug of the feed url.",
+});
+export type RecordName = typeof RecordName.Type;
+
+export const Description = S.String.annotations({
+  description: "The description to be shown to users of the feed.",
+});
+export type Description = typeof Description.Type;
+
+export const Order = S.Union(
+  S.Literal("new"),
+  S.Literal("trending"),
+  S.Literal("blend")
+);
+export type Order = typeof Order.Type;
+
+export const FeedId = S.NumberFromString;
+export type FeedId = typeof FeedId.Type;
+
+export const UserId = S.NumberFromString;
+export type UserId = typeof UserId.Type;
+
+export const AlgorithmManifest = S.Struct({
+  filter: Filter,
+  sort_settings: S.optional(SortSettings),
+});
+export type AlgorithmManifest = typeof AlgorithmManifest.Type;
+
+export const Metadata = S.Struct({
+  document: S.optional(S.Unknown),
+  schema: S.optional(
+    S.Struct({
+      schemaVersion: S.Literal(2),
+      sequences: S.Record({ key: S.String, value: S.Number }),
+    })
+  ),
+  session: S.optional(S.Unknown),
+});
+export type Metadata = typeof Metadata.Type;
+
+export const FullForm = S.Struct({
+  id: FeedId,
+  user_id: UserId,
+  file: S.optional(S.Unknown),
+  display_name: DisplayName,
+  record_name: RecordName,
+  description: S.optional(Description),
+  order: Order,
+  algorithm_manifest: S.parseJson(AlgorithmManifest),
+  metadata: S.optional(S.parseJson(Metadata)),
+});
+export type FullForm = typeof FullForm.Type;
+export type EncodedFullForm = typeof FullForm.Encoded;
+
+/**
+ * Actual structure of FormData
+ *
+ * display_name
+ * record_name
+ * description
+ * order
+ * algorithm_manifest
+ * metadata
+ * id
+ * user_id
+ * session_cookie
+ */

package/src/schema/index.ts

@@ -0,0 +1,2 @@
+export * from "./shared.js";
+export * from "./UpdateAlgorithmPayload.js";

package/src/schema/shared.ts

@@ -0,0 +1,76 @@
+import { Schema as S } from "effect";
+
+export const PartialAlgorithm = S.Struct({
+  algorithm_uri: S.String,
+  algorithm_manifest_id: S.Union(S.Null, S.Number),
+  draft_algorithm_manifest_id: S.Number,
+  record_name: S.String,
+  display_name: S.String,
+  description: S.String,
+  feed_did: S.String,
+  avatar_url: S.Union(S.String, S.Null),
+  cpm_cents: S.Union(S.Number, S.Null),
+  deleted: S.Boolean,
+  active: S.Boolean,
+  public: S.Boolean,
+  monetization_available: S.Boolean,
+  status: S.Union(S.String, S.Null),
+  unique_operator_ids: S.Array(S.Number),
+  user_id: S.Number,
+  id: S.Number,
+  created_at: S.DateFromString,
+  updated_at: S.DateFromString,
+  deleted_at: S.Union(S.DateFromString, S.Null),
+});
+export type PartialAlgorithm = typeof PartialAlgorithm.Type;
+
+const Stats = S.Unknown;
+const LatestError = S.Unknown;
+
+const FullAlgorithm = S.Struct({
+  ...PartialAlgorithm.fields,
+  stats: Stats,
+  latest_error: LatestError,
+  latest_compute_cycle: S.Unknown,
+  subscriber_lists: S.Unknown,
+});
+const FullAlgorithmWithManifest = S.Struct({
+  ...FullAlgorithm.fields,
+  draft_algorithm_manifest: S.Unknown,
+  algorithm_manifest: S.Unknown,
+});
+
+export const AlgoUpdateResponse = S.Struct({
+  message: S.String,
+  algorithm: PartialAlgorithm,
+});
+export type AlgoUpdateResponse = typeof AlgoUpdateResponse.Type;
+
+export const GetAlgoResponse = S.parseJson(FullAlgorithmWithManifest);
+export type GetAlgoResponse = typeof GetAlgoResponse.Type;
+
+export const HidePostBody = S.Struct({
+  algo_id: S.Number,
+  at_uri: S.String,
+});
+export type HidePostBody = typeof HidePostBody.Type;
+
+// ----------------------- Get Algorithms Response -----------------------
+
+export const AlgorithWithStats = S.Struct({
+  ...PartialAlgorithm.fields,
+  stats: S.Struct({
+    page_renders: S.Number,
+    unique_users: S.Number,
+    post_renders: S.Number,
+  }),
+});
+export type AlgorithmWithStats = typeof AlgorithWithStats.Type;
+export const GetAlgorithmsResponse = S.Struct({
+  page: S.Number,
+  page_size: S.Number,
+  total_items: S.Number,
+  total_pages: S.Number,
+  user_algos: S.Array(AlgorithWithStats),
+});
+export type GetAlgorithmsResponse = typeof GetAlgorithmsResponse.Type;

package/test/Dummy.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "@effect/vitest"
+
+describe("Dummy", () => {
+  it("should pass", () => {
+    expect(true).toBe(true)
+  })
+})

package/tsconfig.base.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "exactOptionalPropertyTypes": true,
+    "moduleDetection": "force",
+    "composite": true,
+    "downlevelIteration": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": false,
+    "declaration": true,
+    "skipLibCheck": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": [],
+    "isolatedModules": true,
+    "sourceMap": true,
+    "declarationMap": true,
+    "noImplicitReturns": false,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noEmitOnError": false,
+    "noErrorTruncation": false,
+    "allowJs": false,
+    "checkJs": false,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "noUncheckedIndexedAccess": false,
+    "strictNullChecks": true,
+    "baseUrl": ".",
+    "target": "ES2022",
+    "module": "NodeNext",
+    "incremental": true,
+    "removeComments": false,
+    "plugins": [{ "name": "@effect/language-service" }]
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.src.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "tsBuildInfoFile": ".tsbuildinfo/build.tsbuildinfo",
+    "outDir": "build/esm",
+    "declarationDir": "build/dts",
+    "stripInternal": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": [],
+  "references": [
+    { "path": "tsconfig.src.json" },
+    { "path": "tsconfig.test.json" }
+  ]
+}

package/tsconfig.src.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "types": ["node"],
+    "outDir": "build/src",
+    "tsBuildInfoFile": ".tsbuildinfo/src.tsbuildinfo",
+    "rootDir": "src"
+  }
+}

package/tsconfig.test.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.base.json",
+  "include": ["test"],
+  "references": [
+    { "path": "tsconfig.src.json" }
+  ],
+  "compilerOptions": {
+    "types": ["node"],
+    "tsBuildInfoFile": ".tsbuildinfo/test.tsbuildinfo",
+    "rootDir": "test",
+    "noEmit": true
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import path from "path"
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+  plugins: [],
+  test: {
+    setupFiles: [path.join(__dirname, "setupTests.ts")],
+    include: ["./test/**/*.test.ts"],
+    globals: true
+  },
+  resolve: {
+    alias: {
+      "@template/basic/test": path.join(__dirname, "test"),
+      "@template/basic": path.join(__dirname, "src")
+    }
+  }
+})