feat(#14): Refactored create asset

- Used a more effective approach to create assets
- Logged any errors that might occur
- Simplified the error logging for update asset

Author: jens1101

workspaces/backend/gql/src/gql-server/asset/resolvers/Mutation/createAsset.ts

@@ -1,58 +1,41 @@
 import { dataSource } from "../../../../dataSource.js";
+import { createAsset as createAssetHelper } from "../../../../helpers/asset.js";
+import { withTransaction } from "../../../../scopes/index.js";
 import {
-  type Asset,
-  AssetEntity,
-  type Document,
-  DocumentEntity,
-  FileEntity,
-  type Image,
-  ImageEntity,
-} from "../../../../entities/index.js";
-import type { MutationResolvers } from "./../../../types.generated.js";
-import type { Maybe } from "@app/common";
-import { Decimal } from "decimal.js";
+  DataSourceService,
+  EntityManagerService,
+} from "../../../../services/index.js";
+import type {
+  MutationResolvers,
+  ResolversTypes,
+} from "./../../../types.generated.js";
+import { Effect, pipe } from "effect";
 
 export const createAsset: NonNullable<
   MutationResolvers["createAsset"]
 > = async (_parent, { data }, _ctx) => {
-  const asset = await dataSource.transaction<Asset>(async (manager) => {
-    const asset = await manager.save(AssetEntity, {
-      name: data.name,
-      description: data.description,
-      images: [],
-    });
+  const program = pipe(
+    createAssetHelper(data),
+    Effect.provideServiceEffect(EntityManagerService, withTransaction),
+    Effect.provideService(DataSourceService, dataSource),
+    Effect.scoped,
+    Effect.andThen(
+      (asset) =>
+        ({
+          ...asset,
+          __typename: "Asset",
+        }) as ResolversTypes["AssetResponse"],
+    ),
+    Effect.catchAllCause((cause) =>
+      pipe(
+        Effect.logError("Failed to create asset", cause),
+        Effect.as({
+          __typename: "AssetError",
+          message: "Failed to create asset",
+        } as ResolversTypes["AssetResponse"]),
+      ),
+    ),
+  );
 
-    const images: Image[] = data.images
-      ? await manager.save(
-          ImageEntity,
-          await Promise.all(
-            data.images.map(async (image, index) => ({
-              ...image,
-              asset,
-              position: new Decimal(index),
-              file: await manager.save(FileEntity, image.file),
-            })),
-          ),
-        )
-      : [];
-
-    const proofOfPurchase: Maybe<Document> =
-      data.proofOfPurchase &&
-      (await manager.save(DocumentEntity, {
-        ...data.proofOfPurchase,
-        asset,
-        file: await manager.save(FileEntity, data.proofOfPurchase.file),
-      }));
-
-    return {
-      ...asset,
-      proofOfPurchase,
-      images,
-    } satisfies Asset;
-  });
-
-  return {
-    ...asset,
-    __typename: "Asset",
-  };
+  return Effect.runPromise(program);
 };

workspaces/backend/gql/src/gql-server/asset/resolvers/Mutation/updateAsset.ts

@@ -32,17 +32,6 @@ export const updateAsset: NonNullable<
           __typename: "Asset",
         }) as ResolversTypes["AssetResponse"],
     ),
-    Effect.catchIf(
-      (error) => "_tag" in error,
-      (error) =>
-        pipe(
-          Effect.logWarning("Failed to update asset", error),
-          Effect.as({
-            __typename: "AssetError",
-            message: error.message,
-          } as ResolversTypes["AssetResponse"]),
-        ),
-    ),
     Effect.catchAllCause((cause) =>
       pipe(
         Effect.logError("Failed to update asset", cause),

workspaces/backend/gql/src/helpers/asset.ts

@@ -1,10 +1,16 @@
 import { type Asset, AssetEntity } from "../entities/index.js";
 import { ReadAssetError } from "../errors/ReadAssetError.js";
 import { SaveAssetError } from "../errors/SaveAssetError.js";
-import type { UpdateAssetInput } from "../gql-server/types.generated.js";
+import type {
+  CreateAssetInput,
+  UpdateAssetInput,
+} from "../gql-server/types.generated.js";
 import { EntityManagerService } from "../services/index.js";
-import { mutateImages } from "./image.js";
-import { mutateProofOfPurchase } from "./proofOfPurchase.js";
+import { createImage, mutateImages } from "./image.js";
+import {
+  mutateProofOfPurchase,
+  updateProofOfPurchase,
+} from "./proofOfPurchase.js";
 import { Array, Effect, Option, pipe } from "effect";
 import type { FindOptionsRelations } from "typeorm";
 
@@ -36,22 +42,54 @@ export const readAsset = (
     });
   });
 
+const saveAsset = (input: Partial<Asset>) =>
+  Effect.gen(function* () {
+    const manager = yield* EntityManagerService;
+
+    return yield* Effect.tryPromise({
+      try: async () => (await manager.save(AssetEntity, input)) as Asset,
+      catch: (cause) =>
+        new SaveAssetError({
+          message: "Failed to save asset",
+          options: { cause, input },
+        }),
+    });
+  });
+
+export const createAsset = (input: CreateAssetInput) =>
+  pipe(
+    saveAsset({
+      name: input.name,
+      description: input.description,
+    }),
+    Effect.andThen((asset) =>
+      Option.match(Option.fromNullable(input.proofOfPurchase), {
+        onSome: (proofOfPurchase) =>
+          updateProofOfPurchase(asset, proofOfPurchase),
+        onNone: () => Effect.succeed(asset),
+      }),
+    ),
+    Effect.andThen((asset) =>
+      Option.match(
+        Option.filter(Option.fromNullable(input.images), Array.isNonEmptyArray),
+        {
+          onSome: (images) =>
+            Effect.reduce(Array.reverse(images), asset, (asset, image) =>
+              createImage(asset, image),
+            ),
+          onNone: () => Effect.succeed(asset),
+        },
+      ),
+    ),
+  );
+
 export const updateAsset = (asset: Asset, input: UpdateAssetInput) =>
   pipe(
     Effect.gen(function* () {
-      const manager = yield* EntityManagerService;
-
       if (input.name != null) asset.name = input.name;
       if (input.description != null) asset.description = input.description;
 
-      return yield* Effect.tryPromise({
-        try: async () => await manager.save(AssetEntity, asset),
-        catch: (cause) =>
-          new SaveAssetError({
-            message: "Failed to save document",
-            options: { cause, input },
-          }),
-      });
+      return yield* saveAsset(asset);
     }),
     Effect.andThen((asset) =>
       Option.match(Option.fromNullable(input.proofOfPurchase), {

workspaces/backend/gql/src/helpers/image.ts

@@ -56,7 +56,7 @@ const deleteImage = (input: Image) =>
     yield* deleteFile(input.file);
   });
 
-const createImage = (asset: Asset, input: CreateImageInput) =>
+export const createImage = (asset: Asset, input: CreateImageInput) =>
   Effect.gen(function* () {
     const image = yield* saveImage({
       asset,

workspaces/backend/gql/src/helpers/proofOfPurchase.ts

@@ -18,7 +18,10 @@ export const mutateProofOfPurchase = (
     return yield* deleteProofOfPurchase(asset, input.delete);
   });
 
-const updateProofOfPurchase = (asset: Asset, input: UpdateDocumentInput) =>
+export const updateProofOfPurchase = (
+  asset: Asset,
+  input: UpdateDocumentInput,
+) =>
   Effect.gen(function* () {
     if (asset.proofOfPurchase) yield* deleteDocument(asset.proofOfPurchase);