Merge pull request #26 from aniravi24/first-class-effect-support

feat: first class support for Effect-based workflows

Author: aniravi24

.changeset/breezy-geese-scream.md

@@ -0,0 +1,5 @@
+---
+"typefusion": patch
+---
+
+support Effect in workflows

README.md

@@ -196,7 +196,7 @@ For detailed API documentation, visit the [reference docs](https://aniravi24.git
 
 ## Effect Integration
 
-Typefusion is built with [Effect](https://effect.website). Refer to the reference docs for details on Effect-suffixed functions and their usage.
+Typefusion is built with [Effect](https://effect.website). Refer to the reference docs for details on Effect-suffixed functions and their usage. Most of the time, you just need to suffix the types and functions with `Effect` to use them. For example, `typefusionRef` becomes `typefusionRefEffect`, `TypefusionDbScript` becomes `TypefusionDbScriptEffect`, and `run` becomes `runEffect`.
 
 ## Troubleshooting
 

packages/typefusion/example/main_effect.ts

@@ -0,0 +1,31 @@
+import { Effect } from "effect";
+import { pgType } from "../src/db/postgres/types.js";
+import { TypefusionDbScriptEffect } from "../src/store.js";
+
+export const mainSchema = {
+  id: pgType.integer().notNull(),
+  name: pgType.text().notNull(),
+  age: pgType.integer().notNull(),
+  email: pgType.text().notNull(),
+  address: pgType.text().notNull(),
+};
+
+export default {
+  name: "main_effect",
+  schema: mainSchema,
+  resultDatabase: "postgresql",
+  runEffect: () => {
+    console.log("MAIN IS RUN");
+    return Effect.succeed({
+      data: [
+        {
+          id: 1,
+          name: "John Doe",
+          age: 30,
+          email: "[email protected]",
+          address: "123 Main St",
+        },
+      ],
+    });
+  },
+} satisfies TypefusionDbScriptEffect<typeof mainSchema>;

packages/typefusion/example/postgres/typefusion_effect_ref.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { pgType } from "../../src/index.js";
+import { typefusionRefEffect } from "../../src/lib.js";
+import { TypefusionDbScriptEffect } from "../../src/store.js";
+import mainEffect from "../main_effect.js";
+const smallSchema = {
+  small: pgType.text().notNull(),
+};
+
+export default {
+  name: "typefusion_effect_ref",
+  schema: smallSchema,
+  resultDatabase: "postgresql",
+  runEffect: () =>
+    Effect.gen(function* () {
+      const result = yield* typefusionRefEffect(mainEffect);
+      console.log("TYPEFUSION EFFECT REF IS RUN", result);
+      return {
+        data: [
+          {
+            small: "smallString" as const,
+          },
+        ],
+      };
+    }),
+} satisfies TypefusionDbScriptEffect<typeof smallSchema>;

packages/typefusion/src/helpers.ts

@@ -73,14 +73,17 @@ export function runTypefusionScript(leaf: string) {
         }),
     });
 
-    const result = yield* Effect.tryPromise({
-      try: async () => moduleDefault.run(),
-      catch: (error) =>
-        new ModuleExecutionError({
-          cause: error,
-          message: `Error executing module '${leaf}'`,
-        }),
-    });
+    const result = yield* moduleDefault.runEffect
+      ? moduleDefault.runEffect()
+      : Effect.tryPromise({
+          // Either runEffect or run must be defined, so we'll use the non-null assertion to satisfy TypeScript
+          try: async () => moduleDefault.run!(),
+          catch: (error) =>
+            new ModuleExecutionError({
+              cause: error,
+              message: `Error executing module '${leaf}'`,
+            }),
+        });
 
     return yield* dbInsert(moduleDefault, result);
   });

packages/typefusion/src/lib.ts

@@ -20,7 +20,15 @@ export const typefusionRef = async <T extends TypefusionScriptExport>(
           ? R
           : never;
       }[]
-    : Awaited<ReturnType<T["run"]>>["data"]
+    : T extends { runEffect: (...args: any[]) => any }
+      ? Effect.Effect.Success<ReturnType<T["runEffect"]>> extends {
+          data: infer D;
+        }
+        ? D
+        : never
+      : T extends { run: (...args: any[]) => any }
+        ? Awaited<ReturnType<T["run"]>>["data"]
+        : never
 > => {
   return dbSelect(module).pipe(
     Effect.provide([PgFinalLive, MySqlFinalLive]),
@@ -41,13 +49,19 @@ export const typefusionRefEffect = <T extends TypefusionScriptExport>(
         }
           ? R
           : never;
-      }
-    : Awaited<ReturnType<T["run"]>>["data"],
+      }[]
+    : T extends { runEffect: (...args: any[]) => any }
+      ? Effect.Effect.Success<ReturnType<T["runEffect"]>> extends {
+          data: infer D;
+        }
+        ? D
+        : never
+      : T extends { run: (...args: any[]) => any }
+        ? Awaited<ReturnType<T["run"]>>["data"]
+        : never,
   DatabaseSelectError | ConfigError
 > => {
-  return dbSelect(module).pipe(
-    Effect.provide([PgFinalLive, MySqlFinalLive]),
-  ) as any;
+  return dbSelect(module) as any;
 };
 
 /**

packages/typefusion/src/store.ts

@@ -1,6 +1,7 @@
 import { Schema } from "@effect/schema";
 import { Effect, Data } from "effect";
 import {
+  TypefusionContextEffect,
   TypefusionScriptExport,
   TypefusionScriptResult,
   TypefusionSupportedDatabases,
@@ -28,22 +29,30 @@ const MySqlTypeSchema = Schema.declare(
   },
 );
 
-const ScriptExportSchema = Schema.Struct({
-  name: Schema.String,
-  resultDatabase: Schema.Literal("postgresql", "mysql"),
-  schema: Schema.Union(
-    Schema.Record({
-      key: Schema.String,
-      value: PgTypeSchema,
+const ScriptExportSchema = Schema.extend(
+  Schema.Struct({
+    name: Schema.String,
+    resultDatabase: Schema.Literal("postgresql", "mysql"),
+    schema: Schema.Union(
+      Schema.Record({
+        key: Schema.String,
+        value: PgTypeSchema,
+      }),
+      Schema.Record({
+        key: Schema.String,
+        value: MySqlTypeSchema,
+      }),
+    ).pipe(Schema.optional),
+  }),
+  Schema.Union(
+    Schema.Struct({
+      run: Schema.Any,
     }),
-    Schema.Record({
-      key: Schema.String,
-      value: MySqlTypeSchema,
+    Schema.Struct({
+      runEffect: Schema.Any,
     }),
-  ).pipe(Schema.optional),
-
-  run: Schema.Any,
-});
+  ),
+);
 
 /**
  * The schema for the return type of a Typefusion script `run` function.
@@ -69,6 +78,22 @@ export interface TypefusionScriptDataOnly<
   run: () => PromiseLike<TypefusionScriptResult<DataElement>>;
 }
 
+/**
+ * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `runEffect` function contains the data without any schema.
+ */
+export interface TypefusionScriptDataOnlyEffect<
+  DataElement extends Record<string, unknown>,
+> extends TypefusionScriptExport {
+  schema?: {
+    [key in keyof DataElement]: DbType<DataElement[key]>;
+  };
+  runEffect: <R extends TypefusionContextEffect>() => Effect.Effect<
+    TypefusionScriptResult<DataElement>,
+    any,
+    R
+  >;
+}
+
 /**
  * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `run` function contains both the 'schema' and return data
  * you want to use your existing {@link PgType} or {@link MySqlType} schema.
@@ -83,6 +108,23 @@ export interface TypefusionDbScript<T extends Record<string, DbType<unknown>>>
   >;
 }
 
+/**
+ * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `runEffect` function contains both the 'schema' and return data
+ * you want to use your existing {@link PgType} or {@link MySqlType} schema.
+ */
+export interface TypefusionDbScriptEffect<
+  T extends Record<string, DbType<unknown>>,
+> extends TypefusionScriptExport {
+  schema: T;
+  runEffect: <R extends TypefusionContextEffect>() => Effect.Effect<
+    TypefusionScriptResult<{
+      [key in keyof T]: T[key] extends DbType<infer U> ? U : never;
+    }>,
+    any,
+    R
+  >;
+}
+
 /**
  * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `run` function contains both the 'schema' and return data
  * you want to use your existing {@link PgType} or {@link MySqlType} schema.
@@ -94,6 +136,23 @@ export interface TypefusionDbScriptDataUnknown<
   schema: T;
   run: () => PromiseLike<TypefusionScriptResult<Record<any, any>>>;
 }
+
+/**
+ * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `runEffect` function contains both the 'schema' and return data
+ * you want to use your existing {@link PgType} or {@link MySqlType} schema.
+ * However, the data is unknown, so you can pass in any data array and it will type check.
+ */
+export interface TypefusionDbScriptDataUnknownEffect<
+  T extends Record<string, DbType<unknown>>,
+> extends TypefusionScriptExport {
+  schema: T;
+  runEffect: <R extends TypefusionContextEffect>() => Effect.Effect<
+    TypefusionScriptResult<Record<any, any>>,
+    any,
+    R
+  >;
+}
+
 /**
  * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `run` function contains both the 'schema' and return data.
  * This will check that your `pgType` schema matches the data you are returning, but it's more verbose than using {@link TypefusionDbScript}.
@@ -107,13 +166,37 @@ export interface TypefusionScript<DataElement extends Record<string, unknown>>
   run: () => PromiseLike<TypefusionScriptResult<DataElement>>;
 }
 
+/**
+ * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `runEffect` function contains both the 'schema' and return data.
+ * This will check that your `pgType` schema matches the data you are returning, but it's more verbose than using {@link TypefusionDbScript}.
+ */
+export interface TypefusionScriptEffect<
+  DataElement extends Record<string, unknown>,
+> extends TypefusionScriptExport {
+  schema: {
+    [key in keyof DataElement]: DbType<DataElement[key]>;
+  };
+  runEffect: <R extends TypefusionContextEffect>() => Effect.Effect<
+    TypefusionScriptResult<DataElement>,
+    any,
+    R
+  >;
+}
+
 /**
  * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `run` function contains potentially only the return data.
  * However, the data is unknown, so you can pass in any data array and it will type check.
  */
 export interface TypefusionScriptUnknown
   extends TypefusionScript<Record<string, unknown>> {}
 
+/**
+ * The type of a Typefusion script export ({@link TypefusionScriptExport}) when the result of the `runEffect` function contains potentially only the return data.
+ * However, the data is unknown, so you can pass in any data array and it will type check.
+ */
+export interface TypefusionScriptUnknownEffect
+  extends TypefusionScriptEffect<Record<string, unknown>> {}
+
 export class ConvertDataToSQLDDLError extends Data.TaggedError(
   "ConvertDataToSQLDDLError",
 )<{

packages/typefusion/src/types.ts

@@ -1,20 +1,34 @@
+import { Effect } from "effect";
 import { MySqlType } from "./db/mysql/types.js";
 import { PgType } from "./db/postgres/types.js";
+import { PgDatabaseHelperService, PgService } from "./db/postgres/client.js";
+import { MySQLDatabaseHelperService, MySQLService } from "./db/mysql/client.js";
 
 export type TypefusionSupportedDatabases = "postgresql" | "mysql";
 
 export interface TypefusionScriptResult<T> {
   data: T[];
 }
 
+export type TypefusionContextEffect =
+  | PgService
+  | MySQLService
+  | PgDatabaseHelperService
+  | MySQLDatabaseHelperService;
+
 /**
  * This is a partial type for the 'default' export of an ES Module when importing a Typefusion script.
  */
 export interface TypefusionScriptExport {
   name: string;
   schema?: Record<string, PgType<unknown>> | Record<string, MySqlType<unknown>>;
   resultDatabase: TypefusionSupportedDatabases;
-  run: () => PromiseLike<TypefusionScriptResult<unknown>>;
+  run?: () => PromiseLike<TypefusionScriptResult<unknown>>;
+  runEffect?: <R extends TypefusionContextEffect>() => Effect.Effect<
+    TypefusionScriptResult<unknown>,
+    any,
+    R
+  >;
 }
 
 /**