Merge branch 'next' of git.valverde.cloud:Thilawyn/thilalib into next

package.json

@@ -71,6 +71,7 @@
   },
   "devDependencies": {
     "@effect/schema": "^0.71.1",
+    "@prisma/studio-server": "^0.502.0",
     "@types/jsonwebtoken": "^9.0.6",
     "bun-types": "^1.1.26",
     "effect": "^3.6.5",

src/Layers/PrismaStudioRoute.ts

@@ -0,0 +1,29 @@
+// import { StudioServer } from "@prisma/studio-server"
+// import { Config, Effect, Layer } from "effect"
+
+
+// export const PrismaStudioRouteLive = ({
+//     httpPort = Config.succeed(5555),
+//     schemaPath = Config.succeed(""),
+//     schemaText = Config.succeed(""),
+// }: {
+//     httpPort: Config.Config<number>
+//     schemaPath: Config.Config<string>
+//     schemaText: Config.Config<string>
+// }) =>
+//     Layer.effectDiscard(Effect.gen(function*() {
+
+//         return Effect.acquireRelease(
+//             Effect.gen(function*() {
+//                 const server = new StudioServer({
+//                     port: yield* httpPort,
+//                     schemaPath: yield* schemaPath,
+//                     schemaText: yield* schemaText,
+//                 })
+//             }),
+
+//             () => Effect.gen(function*() {
+
+//             }),
+//         )
+//     }))

src/Schema/MobX/ObservableClass.ts

@@ -8,19 +8,19 @@ interface ObservableClassSelf {
     readonly fields: { readonly [K in keyof Schema.Struct.Fields]: Schema.Struct.Fields[K] }
 }
 
-export const ObservableClass = <Self extends ObservableClassSelf>(
+interface ObservableClassOptions extends Omit<CreateObservableOptions, "proxy"> {}
-    self:      Self,
-    options?:  Omit<CreateObservableOptions, "proxy">,
-) =>
-    class Observable extends self {
-        declare ["constructor"]: typeof Observable
 
-        constructor(...args: any[]) {
+export const ObservableClass = (options?: ObservableClassOptions) =>
-            super(...args)
+    <Self extends ObservableClassSelf>(self: Self) =>
+        class Observable extends self {
+            declare ["constructor"]: typeof Observable
 
-            makeObservable(this,
+            constructor(...args: any[]) {
-                mapValues(this.constructor.fields, () => observable),
+                super(...args)
-                options,
+
-            )
+                makeObservable(this,
-        }
+                    mapValues(this.constructor.fields, () => observable),
-    } as Self
+                    options,
+                )
+            }
+        } as Self

src/Schema/toJsonifiable.ts

@@ -10,4 +10,4 @@ export const toJsonifiable = <
     jsonifiableSchema: Schema.Schema<JsonifiableA, JsonifiableI, JsonifiableR>
 ) =>
     <A, R>(decodedSchema: Schema.Schema<A, JsonifiableA, R>) =>
-        Schema.compose(jsonifiableSchema, decodedSchema)
+        Schema.compose(jsonifiableSchema, decodedSchema, { strict: true })

src/tests.ts

@@ -1,5 +1,5 @@
 import { Schema as S } from "@effect/schema"
-import { reaction, runInAction } from "mobx"
+import { computed, makeObservable, reaction, runInAction } from "mobx"
 import type { Simplify } from "type-fest"
 import { MutableTaggedClass, toJsonifiable } from "./Schema"
 import { ObservableClass } from "./Schema/MobX"
@@ -18,12 +18,24 @@ type TestB = {
 type Merged = Simplify<ExtendAll<[TestA, TestB]>>
 
 
-class User extends MutableTaggedClass<User>()("User", {
+
+const UserSchema = MutableTaggedClass<User>()("User", {
     id:    S.BigIntFromSelf,
     role:  S.Union(S.Literal("BasicUser"), S.Literal("Admin")),
 }).pipe(
-    ObservableClass
+    ObservableClass()
-) {}
+)
+
+class User extends UserSchema {
+    constructor(...args: ConstructorParameters<typeof UserSchema>) {
+        super(...args)
+        makeObservable(this, { idAsString: computed })
+    }
+
+    get idAsString() {
+        return this.id.toString()
+    }
+}
 
 const JsonifiableUser = User.pipe(
     toJsonifiable(S.Struct({