@confect/server 1.0.0-next.0

package/src/Auth.ts

@@ -0,0 +1,31 @@
+import type { Auth as ConvexAuth } from "convex/server";
+import { Effect, flow, Layer, Option, Schema } from "effect";
+
+const make = (auth: ConvexAuth) => ({
+  getUserIdentity: Effect.promise(() => auth.getUserIdentity()).pipe(
+    Effect.andThen(
+      flow(
+        Option.fromNullable,
+        Option.match({
+          onNone: () => Effect.fail(new NoUserIdentityFoundError()),
+          onSome: Effect.succeed,
+        }),
+      ),
+    ),
+  ),
+});
+
+export class Auth extends Effect.Tag("@confect/server/Auth")<
+  Auth,
+  ReturnType<typeof make>
+>() {}
+
+export const layer = (auth: ConvexAuth) => Layer.succeed(Auth, make(auth));
+
+export class NoUserIdentityFoundError extends Schema.TaggedError<NoUserIdentityFoundError>(
+  "NoUserIdentityFoundError",
+)("NoUserIdentityFoundError", {}) {
+  override get message(): string {
+    return "No user identity found";
+  }
+}

package/src/DataModel.ts

@@ -0,0 +1,69 @@
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Table from "./Table";
+import type * as TableInfo from "./TableInfo";
+
+export declare const TypeId: "@confect/server/DataModel";
+export type TypeId = typeof TypeId;
+
+export interface DataModel<Tables_ extends Table.AnyWithProps> {
+  readonly [TypeId]: TypeId;
+  readonly tables: Table.TablesRecord<Tables_>;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export interface AnyWithProps extends Any {
+  readonly tables: Record<string, Table.AnyWithProps>;
+}
+
+export type FromSchema<Schema extends DatabaseSchema.AnyWithProps> = DataModel<
+  DatabaseSchema.Tables<Schema>
+>;
+
+export type FromTables<Tables_ extends Table.AnyWithProps> = DataModel<Tables_>;
+
+export type ToConvex<DataModel_ extends AnyWithProps> = {
+  [TableName_ in TableNames<DataModel_>]: TableInfoWithName<
+    DataModel_,
+    TableName_
+  >;
+};
+
+export type Tables<DataModel_ extends AnyWithProps> =
+  DataModel_ extends DataModel<infer Tables_> ? Tables_ : never;
+
+export type TableNames<DataModel_ extends AnyWithProps> = Table.Name<
+  Tables<DataModel_>
+> &
+  string;
+
+export type TableWithName<
+  DataModel_ extends AnyWithProps,
+  TableName extends TableNames<DataModel_>,
+> = Table.WithName<Tables<DataModel_>, TableName>;
+
+export type TableInfoWithName_<
+  DataModel_ extends AnyWithProps,
+  TableName extends TableNames<DataModel_>,
+> = TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>;
+
+export type TableInfoWithName<
+  DataModel_ extends AnyWithProps,
+  TableName extends TableNames<DataModel_>,
+> = TableInfo.ConvexTableInfo<
+  TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>
+>;
+
+export type DocumentWithName<
+  DataModel_ extends AnyWithProps,
+  TableName extends TableNames<DataModel_>,
+> = TableInfo.Document<
+  TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>
+>;
+
+export type DocumentByName<
+  DataModel_ extends AnyWithProps,
+  TableName extends TableNames<DataModel_>,
+> = DocumentWithName<DataModel_, TableName>;

package/src/DatabaseReader.ts

@@ -0,0 +1,75 @@
+import type { GenericDatabaseReader } from "convex/server";
+import { Array, Context, Layer } from "effect";
+import type { BaseDatabaseReader } from "@confect/core/Types";
+import * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import * as QueryInitializer from "./QueryInitializer";
+import * as Table from "./Table";
+
+export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexDatabaseReader: GenericDatabaseReader<
+    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+  >,
+) => {
+  type Tables = DatabaseSchema.Tables<DatabaseSchema_>;
+  type IncludedTables = DatabaseSchema.IncludeSystemTables<Tables>;
+  const extendedTables = DatabaseSchema.extendWithSystemTables(
+    databaseSchema.tables as Table.TablesRecord<Tables>,
+  );
+
+  return {
+    table: <const TableName extends Table.Name<IncludedTables>>(
+      tableName: TableName,
+    ) => {
+      const table = Object.values(extendedTables).find(
+        (def) => def.name === tableName,
+      ) as Table.WithName<IncludedTables, TableName>;
+
+      const baseDatabaseReader: BaseDatabaseReader<any> = Array.some(
+        Object.values(Table.systemTables),
+        (systemTableDef) => systemTableDef.name === tableName,
+      )
+        ? ({
+            get: convexDatabaseReader.system.get,
+            query: convexDatabaseReader.system.query,
+          } as BaseDatabaseReader<
+            DataModel.ToConvex<DataModel.FromTables<Table.SystemTables>>
+          >)
+        : ({
+            get: convexDatabaseReader.get,
+            query: convexDatabaseReader.query,
+          } as BaseDatabaseReader<
+            DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+          >);
+
+      return QueryInitializer.make<IncludedTables, TableName>(
+        tableName,
+        baseDatabaseReader,
+        table,
+      );
+    },
+  };
+};
+
+export const DatabaseReader = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+>() =>
+  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(
+    "@confect/server/DatabaseReader",
+  );
+
+export type DatabaseReader<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>["Identifier"];
+
+export const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexDatabaseReader: GenericDatabaseReader<
+    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+  >,
+) =>
+  Layer.succeed(
+    DatabaseReader<DatabaseSchema_>(),
+    make(databaseSchema, convexDatabaseReader),
+  );

package/src/DatabaseSchema.ts

@@ -0,0 +1,134 @@
+import type { Expand, GenericSchema } from "convex/server";
+import {
+  defineSchema as defineConvexSchema,
+  type SchemaDefinition,
+} from "convex/server";
+import { Array, pipe, Predicate, Record } from "effect";
+import * as Table from "./Table";
+
+export const TypeId = "@confect/server/DatabaseSchema";
+export type TypeId = typeof TypeId;
+
+export const isSchema = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
+
+/**
+ * A schema definition tracks the schema and its Convex schema definition.
+ */
+export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
+  readonly [TypeId]: TypeId;
+  readonly tables: Table.TablesRecord<Tables_>;
+  readonly convexSchemaDefinition: SchemaDefinition<
+    ConvexDatabaseSchemaFromTables<Tables_>,
+    true
+  >;
+
+  /**
+   * Add a table definition to the schema.
+   */
+  addTable<TableDef extends Table.AnyWithProps>(
+    table: TableDef,
+  ): DatabaseSchema<Tables_ | TableDef>;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export interface AnyWithProps {
+  readonly [TypeId]: TypeId;
+  readonly tables: Record<string, Table.AnyWithProps>;
+  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
+  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;
+}
+
+export type Tables<DatabaseSchema_ extends AnyWithProps> =
+  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;
+
+export type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<
+  Tables<DatabaseSchema_>
+> &
+  string;
+
+export type TableWithName<
+  DatabaseSchema_ extends AnyWithProps,
+  TableName extends TableNames<DatabaseSchema_>,
+> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;
+
+const Proto = {
+  [TypeId]: TypeId,
+
+  addTable<TableDef extends Table.AnyWithProps>(
+    this: DatabaseSchema<Table.AnyWithProps>,
+    table: TableDef,
+  ) {
+    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];
+    const newTablesArray = [...tablesArray, table];
+
+    return makeProto({
+      tables: Record.set(this.tables, table.name, table),
+      convexSchemaDefinition: pipe(
+        newTablesArray,
+        Array.map(
+          ({ name, tableDefinition }) => [name, tableDefinition] as const,
+        ),
+        Record.fromEntries,
+        defineConvexSchema,
+      ),
+    });
+  },
+};
+
+const makeProto = <Tables_ extends Table.AnyWithProps>({
+  tables,
+  convexSchemaDefinition,
+}: {
+  tables: Record.ReadonlyRecord<string, Tables_>;
+  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
+}): DatabaseSchema<Tables_> =>
+  Object.assign(Object.create(Proto), {
+    tables,
+    convexSchemaDefinition,
+  });
+
+/**
+ * Create an empty schema definition. Add tables incrementally via `addTable`.
+ */
+export const make = (): DatabaseSchema<never> =>
+  makeProto({
+    tables: Record.empty(),
+    convexSchemaDefinition: defineConvexSchema({}),
+  });
+
+export type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =
+  Expand<{
+    [TableName in Table.Name<Tables_> & string]: Table.WithName<
+      Tables_,
+      TableName
+    >["tableDefinition"];
+  }>;
+
+// System tables
+
+export const systemSchema = make()
+  .addTable(Table.scheduledFunctionsTable)
+  .addTable(Table.storageTable);
+
+export const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(
+  tables: Table.TablesRecord<Tables_>,
+): ExtendWithSystemTables<Tables_> =>
+  ({
+    ...tables,
+    ...Table.systemTables,
+  }) as ExtendWithSystemTables<Tables_>;
+
+export type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =
+  Table.TablesRecord<Tables_ | Table.SystemTables>;
+
+export type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =
+  | Tables_
+  | Table.SystemTables extends infer T
+  ? T extends Table.AnyWithProps
+    ? T
+    : never
+  : never;

package/src/DatabaseWriter.ts

@@ -0,0 +1,166 @@
+import type {
+  BetterOmit,
+  DocumentByName,
+  Expand,
+  GenericDatabaseWriter,
+  WithoutSystemFields,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import { Context, Effect, Layer, pipe, Record } from "effect";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import type { DocumentByName as DocumentByName_ } from "./DataModel";
+import * as Document from "./Document";
+import * as QueryInitializer from "./QueryInitializer";
+import type * as Table from "./Table";
+import type * as TableInfo from "./TableInfo";
+
+export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexDatabaseWriter: GenericDatabaseWriter<
+    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+  >,
+) => {
+  type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;
+
+  const insert = <TableName extends DataModel.TableNames<DataModel_>>(
+    tableName: TableName,
+    document: Document.WithoutSystemFields<
+      DocumentByName_<DataModel_, TableName>
+    >,
+  ) =>
+    Effect.gen(function* () {
+      const table = (
+        databaseSchema.tables as Record<string, Table.AnyWithProps>
+      )[tableName]!;
+
+      const encodedDocument = yield* Document.encode(
+        document,
+        tableName,
+        table.Fields,
+      );
+
+      const id = yield* Effect.promise(() =>
+        convexDatabaseWriter.insert(
+          tableName,
+          encodedDocument as WithoutSystemFields<
+            DocumentByName<DataModel.ToConvex<DataModel_>, TableName>
+          >,
+        ),
+      );
+
+      return id;
+    });
+
+  const patch = <TableName extends DataModel.TableNames<DataModel_>>(
+    tableName: TableName,
+    id: GenericId<TableName>,
+    patchedValues: Partial<
+      WithoutSystemFields<DocumentByName_<DataModel_, TableName>>
+    >,
+  ) =>
+    Effect.gen(function* () {
+      const table = (
+        databaseSchema.tables as Record<string, Table.AnyWithProps>
+      )[tableName]!;
+
+      const tableSchema = table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >;
+
+      const originalDecodedDoc = yield* QueryInitializer.getById(
+        tableName,
+        convexDatabaseWriter as any,
+        table,
+      )(id);
+
+      const updatedEncodedDoc = yield* pipe(
+        patchedValues,
+        Record.reduce(originalDecodedDoc, (acc, value, key) =>
+          value === undefined
+            ? Record.remove(acc, key)
+            : Record.set(acc, key, value),
+        ),
+        Document.encode(tableName, tableSchema),
+      );
+
+      yield* Effect.promise(() =>
+        convexDatabaseWriter.replace(
+          id,
+          updatedEncodedDoc as Expand<
+            BetterOmit<
+              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
+              "_creationTime" | "_id"
+            >
+          >,
+        ),
+      );
+    });
+
+  const replace = <TableName extends DataModel.TableNames<DataModel_>>(
+    tableName: TableName,
+    id: GenericId<TableName>,
+    value: WithoutSystemFields<DocumentByName_<DataModel_, TableName>>,
+  ) =>
+    Effect.gen(function* () {
+      const table = (
+        databaseSchema.tables as Record<string, Table.AnyWithProps>
+      )[tableName]!;
+
+      const tableSchema = table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >;
+
+      const updatedEncodedDoc = yield* Document.encode(
+        value,
+        tableName,
+        tableSchema,
+      );
+
+      yield* Effect.promise(() =>
+        convexDatabaseWriter.replace(
+          id,
+          updatedEncodedDoc as Expand<
+            BetterOmit<
+              DocumentByName<DataModel.ToConvex<DataModel_>, TableName>,
+              "_creationTime" | "_id"
+            >
+          >,
+        ),
+      );
+    });
+
+  const delete_ = <TableName extends DataModel.TableNames<DataModel_>>(
+    _tableName: TableName,
+    id: GenericId<TableName>,
+  ) => Effect.promise(() => convexDatabaseWriter.delete(id));
+
+  return {
+    insert,
+    patch,
+    replace,
+    delete: delete_,
+  };
+};
+
+export const DatabaseWriter = <
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+>() =>
+  Context.GenericTag<ReturnType<typeof make<DatabaseSchema_>>>(
+    "@confect/server/DatabaseWriter",
+  );
+
+export type DatabaseWriter<
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
+> = ReturnType<typeof DatabaseWriter<DatabaseSchema_>>["Identifier"];
+
+export const layer = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
+  databaseSchema: DatabaseSchema_,
+  convexDatabaseWriter: GenericDatabaseWriter<
+    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
+  >,
+) =>
+  Layer.succeed(
+    DatabaseWriter<DatabaseSchema_>(),
+    make(databaseSchema, convexDatabaseWriter),
+  );

package/src/Document.ts

@@ -0,0 +1,200 @@
+import { Effect, Function, ParseResult, pipe, Schema } from "effect";
+import type { ReadonlyRecord } from "effect/Record";
+import * as SystemFields from "@confect/core/SystemFields";
+import type * as DataModel from "./DataModel";
+import type { ReadonlyValue } from "./SchemaToValidator";
+import type * as TableInfo from "./TableInfo";
+
+export type WithoutSystemFields<Doc> = Omit<Doc, "_creationTime" | "_id">;
+
+export type Any = any;
+export type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;
+
+export const decode = Function.dual<
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ) => (
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["convexDocument"],
+  ) => Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+    DocumentDecodeError
+  >,
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["convexDocument"],
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ) => Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+    DocumentDecodeError
+  >
+>(
+  3,
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["convexDocument"],
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ): Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+    DocumentDecodeError
+  > =>
+    Effect.gen(function* () {
+      const TableSchemaWithSystemFields = SystemFields.extendWithSystemFields(
+        tableName,
+        tableSchema,
+      );
+
+      const encodedDoc =
+        self as (typeof TableSchemaWithSystemFields)["Encoded"];
+
+      const decodedDoc = yield* pipe(
+        encodedDoc,
+        Schema.decode(TableSchemaWithSystemFields),
+        Effect.catchTag("ParseError", (parseError) =>
+          Effect.gen(function* () {
+            const formattedParseError =
+              yield* ParseResult.TreeFormatter.formatError(parseError);
+
+            return yield* new DocumentDecodeError({
+              tableName,
+              id: encodedDoc._id,
+              parseError: formattedParseError,
+            });
+          }),
+        ),
+      );
+
+      return decodedDoc;
+    }),
+);
+
+export const encode = Function.dual<
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ) => (
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+  ) => Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"],
+    DocumentEncodeError
+  >,
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ) => Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"],
+    DocumentEncodeError
+  >
+>(
+  3,
+  <
+    DataModel_ extends DataModel.AnyWithProps,
+    TableName extends DataModel.TableNames<DataModel_>,
+  >(
+    self: DataModel.TableInfoWithName_<DataModel_, TableName>["document"],
+    tableName: TableName,
+    tableSchema: TableInfo.TableSchema<
+      DataModel.TableInfoWithName_<DataModel_, TableName>
+    >,
+  ): Effect.Effect<
+    DataModel.TableInfoWithName_<DataModel_, TableName>["encodedDocument"],
+    DocumentEncodeError
+  > =>
+    Effect.gen(function* () {
+      type TableSchemaWithSystemFields = SystemFields.ExtendWithSystemFields<
+        TableName,
+        TableInfo.TableSchema<
+          DataModel.TableInfoWithName_<DataModel_, TableName>
+        >
+      >;
+
+      const decodedDoc = self as TableSchemaWithSystemFields["Type"];
+
+      const encodedDoc = yield* pipe(
+        decodedDoc,
+        Schema.encode(tableSchema),
+        Effect.catchTag("ParseError", (parseError) =>
+          Effect.gen(function* () {
+            const formattedParseError =
+              yield* ParseResult.TreeFormatter.formatError(parseError);
+
+            return yield* new DocumentEncodeError({
+              tableName,
+              id: decodedDoc._id,
+              parseError: formattedParseError,
+            });
+          }),
+        ),
+      );
+
+      return encodedDoc;
+    }),
+);
+
+export class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>(
+  "DocumentDecodeError",
+)("DocumentDecodeError", {
+  tableName: Schema.String,
+  id: Schema.String,
+  parseError: Schema.String,
+}) {
+  override get message(): string {
+    return documentErrorMessage({
+      id: this.id,
+      tableName: this.tableName,
+      message: `could not be decoded:\n\n${this.parseError}`,
+    });
+  }
+}
+
+export class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>(
+  "DocumentEncodeError",
+)("DocumentEncodeError", {
+  tableName: Schema.String,
+  id: Schema.String,
+  parseError: Schema.String,
+}) {
+  override get message(): string {
+    return documentErrorMessage({
+      id: this.id,
+      tableName: this.tableName,
+      message: `could not be encoded:\n\n${this.parseError}`,
+    });
+  }
+}
+
+export const documentErrorMessage = ({
+  id,
+  tableName,
+  message,
+}: {
+  id: string;
+  tableName: string;
+  message: string;
+}) => `Document with ID '${id}' in table '${tableName}' ${message}`;