Merge pull request #18 from bmthd/feature/decorators

Feature/decorators

Author: bmthd

src/app/server-function/decorator/db.ts

@@ -0,0 +1,12 @@
+import type { User } from "./domain";
+
+/** Mock database */
+export const db = {
+  user: {
+    update: async ({ where, data }: { where: { id: string }; data: User }) => {
+      // Simulate a database update operation
+      console.log(`Updating user with id ${where.id} with data`, data);
+      return { id: where.id, ...data }; // Return the updated user object
+    },
+  },
+};

src/app/server-function/decorator/decorators.ts

@@ -0,0 +1,94 @@
+import { cookies } from "next/headers";
+import { unauthorized } from "next/navigation";
+import * as v from "valibot";
+import { failure, type ResultAsync } from "./result";
+
+export const withValidate = <T extends v.TupleItems>(...schemas: T) => {
+  return <R>(
+    handler: (...args: v.InferOutput<v.TupleSchema<T, any>>) => ResultAsync<R, string>,
+  ) => {
+    return async (...args: v.InferOutput<v.TupleSchema<T, any>>): ResultAsync<R, string> => {
+      const validationResult = v.safeParse(v.tuple(schemas), args);
+      if (!validationResult.success) {
+        return failure("Invalid arguments");
+      }
+      return handler(...args);
+    };
+  };
+};
+
+export const withAuth =
+  <T extends () => void>(handler: T) =>
+  async (): Promise<void> => {
+    const cookie = await cookies();
+    const authToken = cookie.get("auth-token")?.value;
+    if (!authToken) {
+      return unauthorized();
+    }
+    return handler();
+  };
+
+export function pipe<T1, T2>(value: T1, fn: (value: T1) => T2): T2;
+export function pipe<T1, T2, T3>(value: T1, fn1: (value: T1) => T2, fn2: (value: T2) => T3): T3;
+export function pipe<T1, T2, T3, T4>(
+  value: T1,
+  fn1: (value: T1) => T2,
+  fn2: (value: T2) => T3,
+  fn3: (value: T3) => T4,
+): T4;
+export function pipe<T1, T2, T3, T4, T5>(
+  value: T1,
+  fn1: (value: T1) => T2,
+  fn2: (value: T2) => T3,
+  fn3: (value: T3) => T4,
+  fn4: (value: T4) => T5,
+): T5;
+export function pipe<T1, T2, T3, T4, T5, T6>(
+  value: T1,
+  fn1: (value: T1) => T2,
+  fn2: (value: T2) => T3,
+  fn3: (value: T3) => T4,
+  fn4: (value: T4) => T5,
+  fn5: (value: T5) => T6,
+): T6;
+export function pipe(value: unknown, ...fns: Function[]): unknown {
+  return fns.reduce((acc, fn) => fn(acc), value);
+}
+
+export function pipeAsync<T1, T2>(value: T1, fn: (value: T1) => Promise<T2>): Promise<T2>;
+export function pipeAsync<T1, T2, T3>(
+  value: T1,
+  fn1: (value: T1) => Promise<T2>,
+  fn2: (value: T2) => Promise<T3>,
+): Promise<T3>;
+export function pipeAsync<T1, T2, T3, T4>(
+  value: T1,
+  fn1: (value: T1) => Promise<T2>,
+  fn2: (value: T2) => Promise<T3>,
+  fn3: (value: T3) => Promise<T4>,
+): Promise<T4>;
+export function pipeAsync<T1, T2, T3, T4, T5>(
+  value: T1,
+  fn1: (value: T1) => Promise<T2>,
+  fn2: (value: T2) => Promise<T3>,
+  fn3: (value: T3) => Promise<T4>,
+  fn4: (value: T4) => Promise<T5>,
+): Promise<T5>;
+export function pipeAsync<T1, T2, T3, T4, T5, T6>(
+  value: T1,
+  fn1: (value: T1) => Promise<T2>,
+  fn2: (value: T2) => Promise<T3>,
+  fn3: (value: T3) => Promise<T4>,
+  fn4: (value: T4) => Promise<T5>,
+  fn5: (value: T5) => Promise<T6>,
+): Promise<T6>;
+export async function pipeAsync(
+  value: unknown,
+  ...fns: ((...args: unknown[]) => Promise<unknown>)[]
+): Promise<unknown> {
+  let result = value;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}

src/app/server-function/decorator/domain.ts

@@ -0,0 +1,9 @@
+import * as v from "valibot";
+
+export const userSchema = () =>
+  v.object({
+    name: v.string(),
+    email: v.pipe(v.string(), v.email()),
+  });
+
+export type User = v.InferOutput<ReturnType<typeof userSchema>>;

src/app/server-function/decorator/result.ts

@@ -0,0 +1,21 @@
+export type Success<T> = {
+  success: true;
+  data: T;
+};
+
+export type Failure<E> = {
+  success: false;
+  error: E;
+};
+
+export type Result<T, E> = Success<T> | Failure<E>;
+
+export type ResultAsync<T, E> = Promise<Result<T, E>>;
+
+export function success<T>(data: T): Success<T> {
+  return { success: true, data };
+}
+
+export function failure<E>(error: E): Failure<E> {
+  return { success: false, error };
+}

src/app/server-function/decorator/server.ts

@@ -0,0 +1,22 @@
+"use server";
+import * as v from "valibot";
+import { db } from "./db";
+import { withValidate } from "./decorators";
+import { type User, userSchema } from "./domain";
+import { failure, type ResultAsync, success } from "./result";
+
+export const updateUser = withValidate(
+  v.string(),
+  userSchema(),
+)(async (id, user): ResultAsync<User, string> => {
+  // ^? (id: string, user: User)
+  try {
+    const updatedUser = await db.user.update({
+      where: { id },
+      data: user,
+    });
+    return success(updatedUser);
+  } catch {
+    return failure("Failed to update user");
+  }
+});