@confect/server 1.0.0-next.0

package/src/Table.ts

@@ -0,0 +1,439 @@
+import * as SystemFields from "@confect/core/SystemFields";
+import {
+  defineTable,
+  type SystemFields as ConvexSystemFields,
+  type Expand,
+  type GenericTableIndexes,
+  type GenericTableSearchIndexes,
+  type GenericTableVectorIndexes,
+  type IndexTiebreakerField,
+  type SearchIndexConfig,
+  type TableDefinition,
+  type VectorIndexConfig,
+} from "convex/server";
+import type { GenericValidator, Validator } from "convex/values";
+import { Predicate, Schema } from "effect";
+import {
+  compileTableSchema,
+  type TableSchemaToTableValidator,
+} from "./SchemaToValidator";
+
+export const TypeId = "@confect/server/Table";
+export type TypeId = typeof TypeId;
+
+export const isTable = (u: unknown): u is Any =>
+  Predicate.hasProperty(u, TypeId);
+
+export interface Table<
+  Name_ extends string,
+  TableSchema_ extends Schema.Schema.AnyNoContext,
+  TableValidator_ extends
+    GenericValidator = TableSchemaToTableValidator<TableSchema_>,
+  Indexes_ extends GenericTableIndexes = {},
+  SearchIndexes_ extends GenericTableSearchIndexes = {},
+  VectorIndexes_ extends GenericTableVectorIndexes = {},
+> {
+  readonly [TypeId]: TypeId;
+  readonly tableDefinition: TableDefinition<
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  readonly name: Name_;
+
+  readonly Fields: TableSchema_;
+  readonly Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
+
+  readonly indexes: Indexes_;
+
+  index<
+    IndexName extends string,
+    FirstFieldPath extends ExtractFieldPaths<TableValidator_>,
+    RestFieldPaths extends ExtractFieldPaths<TableValidator_>[],
+  >(
+    name: IndexName,
+    fields: [FirstFieldPath, ...RestFieldPaths],
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Expand<
+      Indexes_ &
+        Record<
+          IndexName,
+          [FirstFieldPath, ...RestFieldPaths, IndexTiebreakerField]
+        >
+    >,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  searchIndex<
+    IndexName extends string,
+    SearchField extends ExtractFieldPaths<TableValidator_>,
+    FilterFields extends ExtractFieldPaths<TableValidator_> = never,
+  >(
+    name: IndexName,
+    indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>,
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    Expand<
+      SearchIndexes_ &
+        Record<
+          IndexName,
+          {
+            searchField: SearchField;
+            filterFields: FilterFields;
+          }
+        >
+    >,
+    VectorIndexes_
+  >;
+
+  vectorIndex<
+    IndexName extends string,
+    VectorField extends ExtractFieldPaths<TableValidator_>,
+    FilterFields extends ExtractFieldPaths<TableValidator_> = never,
+  >(
+    name: IndexName,
+    indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>,
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    Expand<
+      VectorIndexes_ &
+        Record<
+          IndexName,
+          {
+            vectorField: VectorField;
+            dimensions: number;
+            filterFields: FilterFields;
+          }
+        >
+    >
+  >;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export type AnyWithProps = Table<
+  any,
+  Schema.Schema.AnyNoContext,
+  GenericValidator,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes
+>;
+
+export type Name<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer TableName,
+    infer _TableSchema,
+    infer _TableValidator,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? TableName & string
+    : never;
+
+export type TableSchema<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer TableSchema_,
+    infer _TableValidator,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? TableSchema_
+    : never;
+
+export type TableValidator<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer _TableSchema,
+    infer TableValidator_,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? TableValidator_
+    : never;
+
+export type Indexes<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer _TableSchema,
+    infer _TableValidator,
+    infer Indexes_,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? Indexes_
+    : never;
+
+export type SearchIndexes<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer _TableSchema,
+    infer _TableValidator,
+    infer _Indexes,
+    infer SearchIndexes_,
+    infer _VectorIndexes
+  >
+    ? SearchIndexes_
+    : never;
+
+export type VectorIndexes<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer _TableSchema,
+    infer _TableValidator,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer VectorIndexes_
+  >
+    ? VectorIndexes_
+    : never;
+
+export type Doc<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer TableName,
+    infer TableSchema_,
+    infer _TableValidator,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? SystemFields.ExtendWithSystemFields<TableName, TableSchema_>
+    : never;
+
+export type Fields<TableDef extends AnyWithProps> =
+  TableDef extends Table<
+    infer _TableName,
+    infer TableSchema_,
+    infer _TableValidator,
+    infer _Indexes,
+    infer _SearchIndexes,
+    infer _VectorIndexes
+  >
+    ? TableSchema_
+    : never;
+
+export type WithName<
+  TableDef extends AnyWithProps,
+  Name_ extends string,
+> = TableDef extends { readonly name: Name_ } ? TableDef : never;
+
+export type TablesRecord<Tables extends AnyWithProps> = {
+  readonly [TableName_ in Name<Tables>]: WithName<Tables, TableName_>;
+};
+
+const Proto = {
+  [TypeId]: TypeId,
+
+  index<
+    IndexName extends string,
+    FirstFieldPath extends string,
+    RestFieldPaths extends string[],
+  >(
+    this: AnyWithProps,
+    name: IndexName,
+    fields: [FirstFieldPath, ...RestFieldPaths],
+  ) {
+    return makeProto({
+      name: this.name,
+      Fields: this.Fields,
+      Doc: this.Doc,
+      tableDefinition: this.tableDefinition.index(name, fields as any),
+      indexes: {
+        ...this.indexes,
+        [name]: fields,
+      },
+    });
+  },
+
+  searchIndex<IndexName extends string, SearchField extends string>(
+    this: AnyWithProps,
+    name: IndexName,
+    indexConfig: SearchIndexConfig<SearchField, any>,
+  ) {
+    return makeProto({
+      name: this.name,
+      Fields: this.Fields,
+      Doc: this.Doc,
+      tableDefinition: this.tableDefinition.searchIndex(name, indexConfig),
+      indexes: this.indexes,
+    });
+  },
+
+  vectorIndex<IndexName extends string, VectorField extends string>(
+    this: AnyWithProps,
+    name: IndexName,
+    indexConfig: {
+      vectorField: VectorField;
+      dimensions: number;
+      filterFields?: string[] | undefined;
+    },
+  ) {
+    return makeProto({
+      name: this.name,
+      Fields: this.Fields,
+      Doc: this.Doc,
+      tableDefinition: this.tableDefinition.vectorIndex(name, {
+        vectorField: indexConfig.vectorField,
+        dimensions: indexConfig.dimensions,
+        ...(indexConfig.filterFields
+          ? { filterFields: indexConfig.filterFields }
+          : {}),
+      }),
+      indexes: this.indexes,
+    });
+  },
+};
+
+const makeProto = <
+  Name_ extends string,
+  TableSchema_ extends Schema.Schema.AnyNoContext,
+  TableValidator_ extends Validator<any, any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+>({
+  name,
+  Fields,
+  Doc,
+  tableDefinition,
+  indexes,
+}: {
+  name: Name_;
+  Fields: TableSchema_;
+  Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
+  tableDefinition: TableDefinition<
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+  indexes: Indexes_;
+}): Table<
+  Name_,
+  TableSchema_,
+  TableValidator_,
+  Indexes_,
+  SearchIndexes_,
+  VectorIndexes_
+> =>
+  Object.assign(Object.create(Proto), {
+    name,
+    Fields,
+    Doc,
+    tableDefinition,
+    indexes,
+  });
+
+/**
+ * Create a table.
+ */
+export const make = <
+  const Name_ extends string,
+  TableSchema_ extends Schema.Schema.AnyNoContext,
+  TableValidator_ extends
+    GenericValidator = TableSchemaToTableValidator<TableSchema_>,
+  Indexes_ extends GenericTableIndexes = {},
+  SearchIndexes_ extends GenericTableSearchIndexes = {},
+  VectorIndexes_ extends GenericTableVectorIndexes = {},
+>(
+  name: Name_,
+  fields: TableSchema_,
+): Table<
+  Name_,
+  TableSchema_,
+  TableValidator_,
+  Indexes_,
+  SearchIndexes_,
+  VectorIndexes_
+> => {
+  const tableValidator = compileTableSchema(fields) as any;
+  const tableDefinition = defineTable(tableValidator) as any;
+
+  return makeProto<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >({
+    name,
+    Fields: fields,
+    Doc: SystemFields.extendWithSystemFields(name, fields),
+    tableDefinition,
+    indexes: {} as Indexes_,
+  });
+};
+
+// -----------------------------------------------------------------------------
+// System tables
+// -----------------------------------------------------------------------------
+
+export const scheduledFunctionsTable = make(
+  "_scheduled_functions",
+  Schema.Struct({
+    name: Schema.String,
+    args: Schema.Array(Schema.Any),
+    scheduledTime: Schema.Number,
+    completedTime: Schema.optionalWith(Schema.Number, { exact: true }),
+    state: Schema.Union(
+      Schema.Struct({ kind: Schema.Literal("pending") }),
+      Schema.Struct({ kind: Schema.Literal("inProgress") }),
+      Schema.Struct({ kind: Schema.Literal("success") }),
+      Schema.Struct({
+        kind: Schema.Literal("failed"),
+        error: Schema.String,
+      }),
+      Schema.Struct({ kind: Schema.Literal("canceled") }),
+    ),
+  }),
+);
+
+export const storageTable = make(
+  "_storage",
+  Schema.Struct({
+    sha256: Schema.String,
+    size: Schema.Number,
+    contentType: Schema.optionalWith(Schema.String, { exact: true }),
+  }),
+);
+
+export const systemTables = {
+  _scheduled_functions: scheduledFunctionsTable,
+  _storage: storageTable,
+} as const;
+
+export type SystemTables = typeof scheduledFunctionsTable | typeof storageTable;
+
+// Vendored types from convex-js, partially modified. Ideally we could use these directly. See https://github.com/get-convex/convex-js/pull/14
+
+/**
+ * Extract all of the index field paths within a {@link Validator}.
+ *
+ * This is used within {@link defineTable}.
+ * @public
+ */
+type ExtractFieldPaths<T extends Validator<any, any, any>> =
+  // Add in the system fields available in index definitions.
+  // This should be everything except for `_id` because thats added to indexes
+  // automatically.
+  T["fieldPaths"] | keyof ConvexSystemFields;

package/src/TableInfo.ts

@@ -0,0 +1,91 @@
+import type {
+  Expand,
+  GenericDocument,
+  GenericFieldPaths,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes,
+  IdField,
+  SystemFields,
+  SystemIndexes,
+} from "convex/server";
+import type { GenericValidator } from "convex/values";
+import type { Schema, Types } from "effect";
+import type * as Document_ from "./Document";
+import type * as Table from "./Table";
+
+export declare const TypeId: "@confect/server/TableInfo";
+export type TypeId = typeof TypeId;
+
+export type TableInfo<Table_ extends Table.AnyWithProps> =
+  Table_ extends Table.Table<
+    infer TableName,
+    infer _TableSchema,
+    infer TableValidator,
+    infer Indexes,
+    infer SearchIndexes,
+    infer VectorIndexes
+  >
+    ? {
+        readonly [TypeId]: TypeId;
+        readonly document: Table_["Doc"]["Type"];
+        readonly encodedDocument: Table_["Doc"]["Encoded"];
+        // TODO: Can we exclude this and derive the convex document type from the encoded document?
+        readonly convexDocument: ExtractConvexDocument<
+          TableName,
+          TableValidator
+        >;
+        readonly fieldPaths:
+          | keyof IdField<TableName>
+          | ExtractFieldPaths<TableValidator>;
+        readonly indexes: Types.Simplify<Indexes & SystemIndexes>;
+        readonly searchIndexes: SearchIndexes;
+        readonly vectorIndexes: VectorIndexes;
+      }
+    : never;
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+}
+
+export interface AnyWithProps extends Any {
+  readonly document: Document_.Any;
+  readonly encodedDocument: Document_.AnyEncoded;
+  readonly convexDocument: GenericDocument;
+  readonly fieldPaths: GenericFieldPaths;
+  readonly indexes: GenericTableIndexes;
+  readonly searchIndexes: GenericTableSearchIndexes;
+  readonly vectorIndexes: GenericTableVectorIndexes;
+}
+
+export type ConvexTableInfo<TableInfo_ extends AnyWithProps> = {
+  document: TableInfo_["convexDocument"];
+  fieldPaths: TableInfo_["fieldPaths"];
+  indexes: TableInfo_["indexes"];
+  searchIndexes: TableInfo_["searchIndexes"];
+  vectorIndexes: TableInfo_["vectorIndexes"];
+};
+
+export type TableSchema<TableInfo_ extends AnyWithProps> = Schema.Schema<
+  TableInfo_["document"],
+  TableInfo_["encodedDocument"]
+>;
+
+export type Document<TableInfo_ extends AnyWithProps> = TableInfo_["document"];
+
+// Vendored types from convex-js, partially modified.
+// See https://github.com/get-convex/convex-js/pull/14
+
+type ExtractFieldPaths<T extends GenericValidator> =
+  | T["fieldPaths"]
+  | keyof SystemFields;
+
+type ExtractConvexDocument<
+  TableName extends string,
+  T extends GenericValidator,
+> =
+  Expand<IdField<TableName> & SystemFields & T["type"]> extends GenericDocument
+    ? Expand<IdField<TableName> & SystemFields & T["type"]>
+    : never;
+
+// End of vendored types from convex-js, partially modified.

package/src/VectorSearch.ts

@@ -0,0 +1,46 @@
+import type {
+  Expand,
+  GenericActionCtx,
+  NamedTableInfo,
+  VectorIndexNames,
+  VectorSearchQuery,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import { Context, Effect, Layer } from "effect";
+import type * as DataModel from "./DataModel";
+
+type ConvexVectorSearch<DataModel_ extends DataModel.AnyWithProps> =
+  GenericActionCtx<DataModel.ToConvex<DataModel_>>["vectorSearch"];
+
+export const make =
+  <DataModel_ extends DataModel.AnyWithProps>(
+    vectorSearch: ConvexVectorSearch<DataModel_>,
+  ) =>
+  <
+    TableName extends DataModel.TableNames<DataModel_>,
+    IndexName extends VectorIndexNames<
+      NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>
+    >,
+  >(
+    tableName: TableName,
+    indexName: IndexName,
+    query: Expand<
+      VectorSearchQuery<
+        NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>,
+        IndexName
+      >
+    >,
+  ): Effect.Effect<Array<{ _id: GenericId<TableName>; _score: number }>> =>
+    Effect.promise(() => vectorSearch(tableName, indexName, query));
+
+export const VectorSearch = <DataModel_ extends DataModel.AnyWithProps>() =>
+  Context.GenericTag<ReturnType<typeof make<DataModel_>>>(
+    "@confect/server/VectorSearch",
+  );
+
+export type VectorSearch<DataModel_ extends DataModel.AnyWithProps> =
+  ReturnType<typeof VectorSearch<DataModel_>>["Identifier"];
+
+export const layer = <DataModel_ extends DataModel.AnyWithProps>(
+  vectorSearch: ConvexVectorSearch<DataModel_>,
+) => Layer.succeed(VectorSearch<DataModel_>(), make(vectorSearch));

package/src/index.ts

@@ -0,0 +1,29 @@
+export * as ActionCtx from "./ActionCtx";
+export * as ActionRunner from "./ActionRunner";
+export * as Api from "./Api";
+export * as Auth from "./Auth";
+export * as DatabaseReader from "./DatabaseReader";
+export * as DatabaseSchema from "./DatabaseSchema";
+export * as DatabaseWriter from "./DatabaseWriter";
+export * as DataModel from "./DataModel";
+export * as Document from "./Document";
+export * as FunctionImpl from "./FunctionImpl";
+export * as GroupImpl from "./GroupImpl";
+export * as Handler from "./Handler";
+export * as HttpApi from "./HttpApi";
+export * as Impl from "./Impl";
+export * as MutationCtx from "./MutationCtx";
+export * as MutationRunner from "./MutationRunner";
+export * as OrderedQuery from "./OrderedQuery";
+export * as QueryCtx from "./QueryCtx";
+export * as QueryInitializer from "./QueryInitializer";
+export * as QueryRunner from "./QueryRunner";
+export * as RegisteredFunctions from "./RegisteredFunctions";
+export * as Registry from "./Registry";
+export * as RegistryItem from "./RegistryItem";
+export * as Scheduler from "./Scheduler";
+export * as SchemaToValidator from "./SchemaToValidator";
+export * as Storage from "./Storage";
+export * as Table from "./Table";
+export * as TableInfo from "./TableInfo";
+export * as VectorSearch from "./VectorSearch";

package/src/internal/utils.ts

@@ -0,0 +1,87 @@
+import type { Predicate } from "effect";
+import { Array, Effect, Record } from "effect";
+
+type NestedObject<T> = {
+  [key: string]: T | NestedObject<T>;
+};
+
+export const mapLeaves = <T, U>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  f: (value: T) => U,
+): NestedObject<U> => {
+  const result: any = {};
+
+  for (const key in obj) {
+    const value = obj[key];
+
+    if (leafRefinement(value)) {
+      result[key] = f(value as T);
+    } else {
+      result[key] = mapLeaves(value as NestedObject<T>, leafRefinement, f);
+    }
+  }
+
+  return result;
+};
+
+const collectBranchLeaves = <T>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  path: string[] = [],
+): { path: string[]; values: Record<string, T> }[] => {
+  const leaves = Record.filter(obj, leafRefinement) as Record<string, T>;
+  const hasLeaves = Record.keys(leaves).length > 0;
+
+  const currentBranch = hasLeaves ? [{ path, values: leaves }] : [];
+
+  const nestedBranches = Array.flatMap(Record.keys(obj), (key) => {
+    const value = obj[key];
+
+    if (!leafRefinement(value) && typeof value === "object") {
+      return collectBranchLeaves(value as NestedObject<T>, leafRefinement, [
+        ...path,
+        key,
+      ]);
+    }
+    return [];
+  });
+
+  return [...currentBranch, ...nestedBranches];
+};
+
+export const forEachBranchLeaves = <T, A, E, R>(
+  obj: NestedObject<T>,
+  leafRefinement: Predicate.Refinement<unknown, T>,
+  f: (branchLeaves: {
+    path: string[];
+    values: Record<string, T>;
+  }) => Effect.Effect<A, E, R>,
+): Effect.Effect<void, E, R> => {
+  const branchLeaves = collectBranchLeaves(obj, leafRefinement);
+  return Effect.forEach(branchLeaves, f, {
+    discard: true,
+  });
+};
+
+export const setNestedProperty = <T extends object>(
+  obj: T,
+  path: PropertyKey[],
+  value: any,
+): T => {
+  if (path.length === 0) {
+    return obj;
+  }
+
+  if (path.length === 1) {
+    const key = path[0] as keyof T;
+    return { ...obj, [key]: value };
+  }
+
+  const [head, ...tail] = path;
+  const key = head as keyof T;
+  return {
+    ...obj,
+    [key]: setNestedProperty((obj as any)[key] ?? {}, tail, value),
+  };
+};