@confect/server 1.0.3 → 3.0.0

package/dist/QueryInitializer.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryInitializer.js","names":["Document.decode","OrderedQuery.make","Document.documentErrorMessage"],"sources":["../src/QueryInitializer.ts"],"sourcesContent":["import type {\n  OrderedQuery as ConvexOrderedQuery,\n  QueryInitializer as ConvexQueryInitializer,\n  DocumentByInfo,\n  GenericTableIndexes,\n  GenericTableInfo,\n  Indexes,\n  IndexRange,\n  IndexRangeBuilder,\n  NamedIndex,\n  NamedSearchIndex,\n  NamedTableInfo,\n  Query,\n  SearchFilter,\n  SearchFilterBuilder,\n  SearchIndexes,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Array, Effect, Either, pipe, Schema } from \"effect\";\nimport type {\n  BaseDatabaseReader,\n  IndexFieldTypesForEq,\n} from \"@confect/core/Types\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as OrderedQuery from \"./OrderedQuery\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\ntype QueryInitializer<\n  DataModel_ extends DataModel.AnyWithProps,\n  TableName extends DataModel.TableNames<DataModel_>,\n  _ConvexTableInfo extends GenericTableInfo,\n  _TableInfo extends TableInfo.AnyWithProps,\n> = {\n  readonly get: {\n    (\n      id: GenericId<TableName>,\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIdFailure\n    >;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      ...indexFieldValues: IndexFieldTypesForEq<\n        DataModel.ToConvex<DataModel_>,\n        TableName,\n        Indexes<_ConvexTableInfo>[IndexName]\n      >\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIndexFailure\n    >;\n  };\n  readonly index: {\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      indexRange?: (\n        q: IndexRangeBuilder<\n          _TableInfo[\"convexDocument\"],\n          NamedIndex<_ConvexTableInfo, IndexName>\n        >,\n      ) => IndexRange,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n  };\n  readonly search: <IndexName extends keyof SearchIndexes<_ConvexTableInfo>>(\n    indexName: IndexName,\n    searchFilter: (\n      q: SearchFilterBuilder<\n        DocumentByInfo<_ConvexTableInfo>,\n        NamedSearchIndex<_ConvexTableInfo, IndexName>\n      >,\n    ) => SearchFilter,\n  ) => OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n};\n\nexport const make = <\n  Tables extends Table.AnyWithProps,\n  TableName extends Table.Name<Tables>,\n>(\n  tableName: TableName,\n  convexDatabaseReader: BaseDatabaseReader<\n    DataModel.ToConvex<DataModel.FromTables<Tables>>\n  >,\n  table: Table.WithName<Tables, TableName>,\n): QueryInitializer<\n  DataModel.DataModel<Tables>,\n  TableName,\n  DataModel.TableInfoWithName<DataModel.DataModel<Tables>, TableName>,\n  DataModel.TableInfoWithName_<DataModel.DataModel<Tables>, TableName>\n> => {\n  type DataModel_ = DataModel.DataModel<Tables>;\n  type ConvexDataModel_ = DataModel.ToConvex<DataModel_>;\n  type ThisQueryInitializer = QueryInitializer<\n    DataModel_,\n    TableName,\n    DataModel.TableInfoWithName<DataModel_, TableName>,\n    DataModel.TableInfoWithName_<DataModel_, TableName>\n  >;\n  type QueryInitializerFunction<\n    FunctionName extends keyof ThisQueryInitializer,\n  > = ThisQueryInitializer[FunctionName];\n\n  const getByIndex = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexFieldValues: IndexFieldTypesForEq<\n      DataModel.ToConvex<DataModel_>,\n      TableName,\n      Indexes<DataModel.TableInfoWithName<DataModel_, TableName>>[IndexName]\n    >,\n  ): Effect.Effect<\n    DataModel.DocumentWithName<DataModel_, TableName>,\n    Document.DocumentDecodeError | GetByIndexFailure\n  > => {\n    const indexFields: GenericTableIndexes[keyof GenericTableIndexes] = (\n      table.indexes as GenericTableIndexes\n    )[indexName as keyof GenericTableIndexes]!;\n\n    return pipe(\n      Effect.promise(() =>\n        convexDatabaseReader\n          .query(tableName)\n          .withIndex(indexName, (q) =>\n            Array.reduce(\n              indexFieldValues,\n              q,\n              (q_, v, i) => q_.eq(indexFields[i] as any, v as any) as any,\n            ),\n          )\n          .unique(),\n      ),\n      Effect.andThen(\n        Either.fromNullable(\n          () =>\n            new GetByIndexFailure({\n              tableName,\n              indexName: indexName as string,\n              indexFieldValues: indexFieldValues as string[],\n            }),\n        ),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n  };\n\n  const get: QueryInitializerFunction<\"get\"> = ((\n    ...args: Parameters<QueryInitializerFunction<\"get\">>\n  ) => {\n    if (args.length === 1) {\n      const id = args[0] as GenericId<TableName>;\n\n      return getById(tableName, convexDatabaseReader, table)(id);\n    } else {\n      const [indexName, ...indexFieldValues] = args;\n\n      return getByIndex(\n        indexName as keyof Indexes<\n          DataModel.TableInfoWithName<DataModel_, TableName>\n        >,\n        indexFieldValues,\n      );\n    }\n  }) as QueryInitializerFunction<\"get\">;\n\n  const index: QueryInitializerFunction<\"index\"> = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexRangeOrOrder?:\n      | ((\n          q: IndexRangeBuilder<\n            DataModel.TableInfoWithName_<\n              DataModel_,\n              TableName\n            >[\"convexDocument\"],\n            NamedIndex<\n              DataModel.TableInfoWithName<DataModel_, TableName>,\n              IndexName\n            >\n          >,\n        ) => IndexRange)\n      | \"asc\"\n      | \"desc\",\n    order?: \"asc\" | \"desc\",\n  ) => {\n    const {\n      applyWithIndex,\n      applyOrder,\n    }: {\n      applyWithIndex: (\n        queryInitializer: ConvexQueryInitializer<\n          NamedTableInfo<ConvexDataModel_, TableName>\n        >,\n      ) => Query<NamedTableInfo<ConvexDataModel_, TableName>>;\n      applyOrder: (\n        query: Query<NamedTableInfo<ConvexDataModel_, TableName>>,\n      ) => ConvexOrderedQuery<NamedTableInfo<ConvexDataModel_, TableName>>;\n    } =\n      indexRangeOrOrder === undefined\n        ? {\n            applyWithIndex: (q) => q.withIndex(indexName),\n            applyOrder: (q) => q.order(\"asc\"),\n          }\n        : typeof indexRangeOrOrder === \"function\"\n          ? order === undefined\n            ? {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(\"asc\"),\n              }\n            : {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(order),\n              }\n          : {\n              applyWithIndex: (q) => q.withIndex(indexName),\n              applyOrder: (q) => q.order(indexRangeOrOrder),\n            };\n\n    const orderedQuery = pipe(\n      convexDatabaseReader.query(tableName),\n      applyWithIndex,\n      applyOrder,\n    );\n\n    return OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(orderedQuery, tableName, table.Fields);\n  };\n\n  const search: QueryInitializerFunction<\"search\"> = (\n    indexName,\n    searchFilter,\n  ) =>\n    OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      convexDatabaseReader\n        .query(tableName)\n        .withSearchIndex(indexName, searchFilter),\n      tableName,\n      table.Fields,\n    );\n\n  return {\n    get,\n    index,\n    search,\n  };\n};\n\nexport const getById =\n  <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(\n    tableName: TableName,\n    convexDatabaseReader: BaseDatabaseReader<\n      DataModel.ToConvex<DataModel.FromTables<Tables>>\n    >,\n    table: Table.WithName<Tables, TableName>,\n  ) =>\n  (id: GenericId<TableName>) =>\n    pipe(\n      Effect.promise(() => convexDatabaseReader.get(id)),\n      Effect.andThen(\n        Either.fromNullable(() => new GetByIdFailure({ tableName, id })),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n\nexport class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>(\n  \"GetByIdFailure\",\n)(\"GetByIdFailure\", {\n  id: Schema.String,\n  tableName: Schema.String,\n}) {\n  override get message(): string {\n    return Document.documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: \"not found\",\n    });\n  }\n}\n\nexport class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>(\n  \"GetByIndexFailure\",\n)(\"GetByIndexFailure\", {\n  tableName: Schema.String,\n  indexName: Schema.String,\n  indexFieldValues: Schema.Array(Schema.String),\n}) {\n  override get message(): string {\n    return `No documents found in table '${this.tableName}' with index '${this.indexName}' and field values '${this.indexFieldValues}'`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAiFA,MAAa,QAIX,WACA,sBAGA,UAMG;CAaH,MAAM,cAKJ,WACA,qBAQG;EACH,MAAM,cACJ,MAAM,QACN;AAEF,SAAO,KACL,OAAO,cACL,qBACG,MAAM,UAAU,CAChB,UAAU,YAAY,MACrB,MAAM,OACJ,kBACA,IACC,IAAI,GAAG,MAAM,GAAG,GAAG,YAAY,IAAW,EAAS,CACrD,CACF,CACA,QAAQ,CACZ,EACD,OAAO,QACL,OAAO,mBAEH,IAAI,kBAAkB;GACpB;GACW;GACO;GACnB,CAAC,CACL,CACF,EACD,OAAO,QAAQA,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;;CAGH,MAAM,QACJ,GAAG,SACA;AACH,MAAI,KAAK,WAAW,GAAG;GACrB,MAAM,KAAK,KAAK;AAEhB,UAAO,QAAQ,WAAW,sBAAsB,MAAM,CAAC,GAAG;SACrD;GACL,MAAM,CAAC,WAAW,GAAG,oBAAoB;AAEzC,UAAO,WACL,WAGA,iBACD;;;CAIL,MAAM,SAKJ,WACA,mBAeA,UACG;EACH,MAAM,EACJ,gBACA,eAWA,sBAAsB,SAClB;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD,OAAO,sBAAsB,aAC3B,UAAU,SACR;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACH;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,kBAAkB;GAC9C;EAET,MAAM,eAAe,KACnB,qBAAqB,MAAM,UAAU,EACrC,gBACA,WACD;AAED,SAAOC,OAGL,cAAc,WAAW,MAAM,OAAO;;CAG1C,MAAM,UACJ,WACA,iBAEAA,OAIE,qBACG,MAAM,UAAU,CAChB,gBAAgB,WAAW,aAAa,EAC3C,WACA,MAAM,OACP;AAEH,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,WAET,WACA,sBAGA,WAED,OACC,KACE,OAAO,cAAc,qBAAqB,IAAI,GAAG,CAAC,EAClD,OAAO,QACL,OAAO,mBAAmB,IAAI,eAAe;CAAE;CAAW;CAAI,CAAC,CAAC,CACjE,EACD,OAAO,QAAQD,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;AAEL,IAAa,iBAAb,cAAoC,OAAO,YACzC,iBACD,CAAC,kBAAkB;CAClB,IAAI,OAAO;CACX,WAAW,OAAO;CACnB,CAAC,CAAC;CACD,IAAa,UAAkB;AAC7B,SAAOE,qBAA8B;GACnC,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS;GACV,CAAC;;;AAIN,IAAa,oBAAb,cAAuC,OAAO,YAC5C,oBACD,CAAC,qBAAqB;CACrB,WAAW,OAAO;CAClB,WAAW,OAAO;CAClB,kBAAkB,OAAO,MAAM,OAAO,OAAO;CAC9C,CAAC,CAAC;CACD,IAAa,UAAkB;AAC7B,SAAO,gCAAgC,KAAK,UAAU,gBAAgB,KAAK,UAAU,sBAAsB,KAAK,iBAAiB"}
+{"version":3,"file":"QueryInitializer.js","names":["Document.decode","OrderedQuery.make","Document.documentErrorMessage"],"sources":["../src/QueryInitializer.ts"],"sourcesContent":["import type {\n  OrderedQuery as ConvexOrderedQuery,\n  QueryInitializer as ConvexQueryInitializer,\n  DocumentByInfo,\n  GenericTableIndexes,\n  GenericTableInfo,\n  Indexes,\n  IndexRange,\n  IndexRangeBuilder,\n  NamedIndex,\n  NamedSearchIndex,\n  NamedTableInfo,\n  Query,\n  SearchFilter,\n  SearchFilterBuilder,\n  SearchIndexes,\n} from \"convex/server\";\nimport type { GenericId } from \"convex/values\";\nimport { Array, Effect, Either, pipe, Schema } from \"effect\";\nimport type {\n  BaseDatabaseReader,\n  IndexFieldTypesForEq,\n} from \"@confect/core/Types\";\nimport type * as DataModel from \"./DataModel\";\nimport * as Document from \"./Document\";\nimport * as OrderedQuery from \"./OrderedQuery\";\nimport type * as Table from \"./Table\";\nimport type * as TableInfo from \"./TableInfo\";\n\ntype QueryInitializer<\n  DataModel_ extends DataModel.AnyWithProps,\n  TableName extends DataModel.TableNames<DataModel_>,\n  _ConvexTableInfo extends GenericTableInfo,\n  _TableInfo extends TableInfo.AnyWithProps,\n> = {\n  readonly get: {\n    (\n      id: GenericId<TableName>,\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIdFailure\n    >;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      ...indexFieldValues: IndexFieldTypesForEq<\n        DataModel.ToConvex<DataModel_>,\n        TableName,\n        Indexes<_ConvexTableInfo>[IndexName]\n      >\n    ): Effect.Effect<\n      _TableInfo[\"document\"],\n      Document.DocumentDecodeError | GetByIndexFailure\n    >;\n  };\n  readonly index: {\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      indexRange?: (\n        q: IndexRangeBuilder<\n          _TableInfo[\"convexDocument\"],\n          NamedIndex<_ConvexTableInfo, IndexName>\n        >,\n      ) => IndexRange,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n    <IndexName extends keyof Indexes<_ConvexTableInfo>>(\n      indexName: IndexName,\n      order?: \"asc\" | \"desc\",\n    ): OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n  };\n  readonly search: <IndexName extends keyof SearchIndexes<_ConvexTableInfo>>(\n    indexName: IndexName,\n    searchFilter: (\n      q: SearchFilterBuilder<\n        DocumentByInfo<_ConvexTableInfo>,\n        NamedSearchIndex<_ConvexTableInfo, IndexName>\n      >,\n    ) => SearchFilter,\n  ) => OrderedQuery.OrderedQuery<_TableInfo, TableName>;\n};\n\nexport const make = <\n  Tables extends Table.AnyWithProps,\n  TableName extends Table.Name<Tables>,\n>(\n  tableName: TableName,\n  convexDatabaseReader: BaseDatabaseReader<\n    DataModel.ToConvex<DataModel.FromTables<Tables>>\n  >,\n  table: Table.WithName<Tables, TableName>,\n): QueryInitializer<\n  DataModel.DataModel<Tables>,\n  TableName,\n  DataModel.TableInfoWithName<DataModel.DataModel<Tables>, TableName>,\n  DataModel.TableInfoWithName_<DataModel.DataModel<Tables>, TableName>\n> => {\n  type DataModel_ = DataModel.DataModel<Tables>;\n  type ConvexDataModel_ = DataModel.ToConvex<DataModel_>;\n  type ThisQueryInitializer = QueryInitializer<\n    DataModel_,\n    TableName,\n    DataModel.TableInfoWithName<DataModel_, TableName>,\n    DataModel.TableInfoWithName_<DataModel_, TableName>\n  >;\n  type QueryInitializerFunction<\n    FunctionName extends keyof ThisQueryInitializer,\n  > = ThisQueryInitializer[FunctionName];\n\n  const getByIndex = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexFieldValues: IndexFieldTypesForEq<\n      DataModel.ToConvex<DataModel_>,\n      TableName,\n      Indexes<DataModel.TableInfoWithName<DataModel_, TableName>>[IndexName]\n    >,\n  ): Effect.Effect<\n    DataModel.DocumentWithName<DataModel_, TableName>,\n    Document.DocumentDecodeError | GetByIndexFailure\n  > => {\n    const indexFields: GenericTableIndexes[keyof GenericTableIndexes] = (\n      table.indexes as GenericTableIndexes\n    )[indexName as keyof GenericTableIndexes]!;\n\n    return pipe(\n      Effect.promise(() =>\n        convexDatabaseReader\n          .query(tableName)\n          .withIndex(indexName, (q) =>\n            Array.reduce(\n              indexFieldValues,\n              q,\n              (q_, v, i) => q_.eq(indexFields[i] as any, v as any) as any,\n            ),\n          )\n          .unique(),\n      ),\n      Effect.andThen(\n        Either.fromNullable(\n          () =>\n            new GetByIndexFailure({\n              tableName,\n              indexName: indexName as string,\n              indexFieldValues: indexFieldValues as string[],\n            }),\n        ),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n  };\n\n  const get: QueryInitializerFunction<\"get\"> = ((\n    ...args: Parameters<QueryInitializerFunction<\"get\">>\n  ) => {\n    if (args.length === 1) {\n      const id = args[0] as GenericId<TableName>;\n\n      return getById(tableName, convexDatabaseReader, table)(id);\n    } else {\n      const [indexName, ...indexFieldValues] = args;\n\n      return getByIndex(\n        indexName as keyof Indexes<\n          DataModel.TableInfoWithName<DataModel_, TableName>\n        >,\n        indexFieldValues,\n      );\n    }\n  }) as QueryInitializerFunction<\"get\">;\n\n  const index: QueryInitializerFunction<\"index\"> = <\n    IndexName extends keyof Indexes<\n      DataModel.TableInfoWithName<DataModel_, TableName>\n    >,\n  >(\n    indexName: IndexName,\n    indexRangeOrOrder?:\n      | ((\n          q: IndexRangeBuilder<\n            DataModel.TableInfoWithName_<\n              DataModel_,\n              TableName\n            >[\"convexDocument\"],\n            NamedIndex<\n              DataModel.TableInfoWithName<DataModel_, TableName>,\n              IndexName\n            >\n          >,\n        ) => IndexRange)\n      | \"asc\"\n      | \"desc\",\n    order?: \"asc\" | \"desc\",\n  ) => {\n    const {\n      applyWithIndex,\n      applyOrder,\n    }: {\n      applyWithIndex: (\n        queryInitializer: ConvexQueryInitializer<\n          NamedTableInfo<ConvexDataModel_, TableName>\n        >,\n      ) => Query<NamedTableInfo<ConvexDataModel_, TableName>>;\n      applyOrder: (\n        query: Query<NamedTableInfo<ConvexDataModel_, TableName>>,\n      ) => ConvexOrderedQuery<NamedTableInfo<ConvexDataModel_, TableName>>;\n    } =\n      indexRangeOrOrder === undefined\n        ? {\n            applyWithIndex: (q) => q.withIndex(indexName),\n            applyOrder: (q) => q.order(\"asc\"),\n          }\n        : typeof indexRangeOrOrder === \"function\"\n          ? order === undefined\n            ? {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(\"asc\"),\n              }\n            : {\n                applyWithIndex: (q) =>\n                  q.withIndex(indexName, indexRangeOrOrder),\n                applyOrder: (q) => q.order(order),\n              }\n          : {\n              applyWithIndex: (q) => q.withIndex(indexName),\n              applyOrder: (q) => q.order(indexRangeOrOrder),\n            };\n\n    const orderedQuery = pipe(\n      convexDatabaseReader.query(tableName),\n      applyWithIndex,\n      applyOrder,\n    );\n\n    return OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(orderedQuery, tableName, table.Fields);\n  };\n\n  const search: QueryInitializerFunction<\"search\"> = (\n    indexName,\n    searchFilter,\n  ) =>\n    OrderedQuery.make<\n      DataModel.TableInfoWithName_<DataModel_, TableName>,\n      TableName\n    >(\n      convexDatabaseReader\n        .query(tableName)\n        .withSearchIndex(indexName, searchFilter),\n      tableName,\n      table.Fields,\n    );\n\n  return {\n    get,\n    index,\n    search,\n  };\n};\n\nexport const getById =\n  <Tables extends Table.AnyWithProps, TableName extends Table.Name<Tables>>(\n    tableName: TableName,\n    convexDatabaseReader: BaseDatabaseReader<\n      DataModel.ToConvex<DataModel.FromTables<Tables>>\n    >,\n    table: Table.WithName<Tables, TableName>,\n  ) =>\n  (id: GenericId<TableName>) =>\n    pipe(\n      Effect.promise(() => convexDatabaseReader.get(id)),\n      Effect.andThen(\n        Either.fromNullable(() => new GetByIdFailure({ tableName, id })),\n      ),\n      Effect.andThen(Document.decode(tableName, table.Fields)),\n    );\n\nexport class GetByIdFailure extends Schema.TaggedError<GetByIdFailure>()(\n  \"GetByIdFailure\",\n  {\n    id: Schema.String,\n    tableName: Schema.String,\n  },\n) {\n  override get message(): string {\n    return Document.documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: \"not found\",\n    });\n  }\n}\n\nexport class GetByIndexFailure extends Schema.TaggedError<GetByIndexFailure>()(\n  \"GetByIndexFailure\",\n  {\n    tableName: Schema.String,\n    indexName: Schema.String,\n    indexFieldValues: Schema.Array(Schema.String),\n  },\n) {\n  override get message(): string {\n    return `No documents found in table '${this.tableName}' with index '${this.indexName}' and field values '${this.indexFieldValues}'`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAiFA,MAAa,QAIX,WACA,sBAGA,UAMG;CAaH,MAAM,cAKJ,WACA,qBAQG;EACH,MAAM,cACJ,MAAM,QACN;AAEF,SAAO,KACL,OAAO,cACL,qBACG,MAAM,UAAU,CAChB,UAAU,YAAY,MACrB,MAAM,OACJ,kBACA,IACC,IAAI,GAAG,MAAM,GAAG,GAAG,YAAY,IAAW,EAAS,CACrD,CACF,CACA,QAAQ,CACZ,EACD,OAAO,QACL,OAAO,mBAEH,IAAI,kBAAkB;GACpB;GACW;GACO;GACnB,CAAC,CACL,CACF,EACD,OAAO,QAAQA,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;;CAGH,MAAM,QACJ,GAAG,SACA;AACH,MAAI,KAAK,WAAW,GAAG;GACrB,MAAM,KAAK,KAAK;AAEhB,UAAO,QAAQ,WAAW,sBAAsB,MAAM,CAAC,GAAG;SACrD;GACL,MAAM,CAAC,WAAW,GAAG,oBAAoB;AAEzC,UAAO,WACL,WAGA,iBACD;;;CAIL,MAAM,SAKJ,WACA,mBAeA,UACG;EACH,MAAM,EACJ,gBACA,eAWA,sBAAsB,SAClB;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD,OAAO,sBAAsB,aAC3B,UAAU,SACR;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACD;GACE,iBAAiB,MACf,EAAE,UAAU,WAAW,kBAAkB;GAC3C,aAAa,MAAM,EAAE,MAAM,MAAM;GAClC,GACH;GACE,iBAAiB,MAAM,EAAE,UAAU,UAAU;GAC7C,aAAa,MAAM,EAAE,MAAM,kBAAkB;GAC9C;EAET,MAAM,eAAe,KACnB,qBAAqB,MAAM,UAAU,EACrC,gBACA,WACD;AAED,SAAOC,OAGL,cAAc,WAAW,MAAM,OAAO;;CAG1C,MAAM,UACJ,WACA,iBAEAA,OAIE,qBACG,MAAM,UAAU,CAChB,gBAAgB,WAAW,aAAa,EAC3C,WACA,MAAM,OACP;AAEH,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,WAET,WACA,sBAGA,WAED,OACC,KACE,OAAO,cAAc,qBAAqB,IAAI,GAAG,CAAC,EAClD,OAAO,QACL,OAAO,mBAAmB,IAAI,eAAe;CAAE;CAAW;CAAI,CAAC,CAAC,CACjE,EACD,OAAO,QAAQD,OAAgB,WAAW,MAAM,OAAO,CAAC,CACzD;AAEL,IAAa,iBAAb,cAAoC,OAAO,aAA6B,CACtE,kBACA;CACE,IAAI,OAAO;CACX,WAAW,OAAO;CACnB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAOE,qBAA8B;GACnC,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS;GACV,CAAC;;;AAIN,IAAa,oBAAb,cAAuC,OAAO,aAAgC,CAC5E,qBACA;CACE,WAAW,OAAO;CAClB,WAAW,OAAO;CAClB,kBAAkB,OAAO,MAAM,OAAO,OAAO;CAC9C,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,gCAAgC,KAAK,UAAU,gBAAgB,KAAK,UAAU,sBAAsB,KAAK,iBAAiB"}

package/dist/QueryRunner.d.ts

@@ -6,9 +6,9 @@ import { GenericQueryCtx } from "convex/server";
 declare namespace QueryRunner_d_exports {
   export { QueryRunner, layer };
 }
-declare const QueryRunner: Context.Tag<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>["Type"]) => Effect.Effect<Ref$1.Returns<Query>["Type"], ParseResult.ParseError>), <Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>["Type"]) => Effect.Effect<Ref$1.Returns<Query>["Type"], ParseResult.ParseError>>;
+declare const QueryRunner: Context.Tag<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>), <Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>>;
 type QueryRunner = typeof QueryRunner.Identifier;
-declare const layer: (runQuery: GenericQueryCtx<any>["runQuery"]) => Layer.Layer<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>["Type"]) => Effect.Effect<Ref$1.Returns<Query>["Type"], ParseResult.ParseError>), never, never>;
+declare const layer: (runQuery: GenericQueryCtx<any>["runQuery"]) => Layer.Layer<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>), never, never>;
 //#endregion
 export { QueryRunner, QueryRunner_d_exports, layer };
 //# sourceMappingURL=QueryRunner.d.ts.map

package/dist/QueryRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryRunner.d.ts","names":[],"sources":["../src/QueryRunner.ts"],"mappings":";;;;;;;;cAsBa,WAAA,EAAW,OAAA,CAAA,GAAA,iBAfP,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,cACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,WAAgB,WAAA,CAAY,UAAA,mBAH1C,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,cACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,WAAgB,WAAA,CAAY,UAAA;AAAA,KAe/C,WAAA,UAAqB,WAAA,CAAY,UAAA;AAAA,cAEhC,KAAA,GAAS,QAAA,EAAU,eAAA,sBAAgC,KAAA,CAAA,KAAA,iBApB/C,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,cACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,WAAgB,WAAA,CAAY,UAAA"}
+{"version":3,"file":"QueryRunner.d.ts","names":[],"sources":["../src/QueryRunner.ts"],"mappings":";;;;;;;;cAoCa,WAAA,EAAW,OAAA,CAAA,GAAA,iBA7BP,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA,mBAHlC,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA;AAAA,KA6BvC,WAAA,UAAqB,WAAA,CAAY,UAAA;AAAA,cAEhC,KAAA,GAAS,QAAA,EAAU,eAAA,sBAAgC,KAAA,CAAA,KAAA,iBAlC/C,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA"}

package/dist/QueryRunner.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Match, Schema } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import "convex/server";
 
@@ -9,11 +9,13 @@ var QueryRunner_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer
 });
 const make = (runQuery) => (query, args) => Effect.gen(function* () {
-	const function_ = Ref$1.getFunction(query);
+	const functionSpec = Ref$1.getFunctionSpec(query);
 	const functionName = Ref$1.getConvexFunctionName(query);
-	const encodedArgs = yield* Schema.encode(function_.args)(args);
-	const encodedReturns = yield* Effect.promise(() => runQuery(functionName, encodedArgs));
-	return yield* Schema.decode(function_.returns)(encodedReturns);
+	return yield* Match.value(functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionSpec) => Effect.gen(function* () {
+		const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(args);
+		const encodedReturns = yield* Effect.promise(() => runQuery(functionName, encodedArgs));
+		return yield* Schema.decode(confectFunctionSpec.returns)(encodedReturns);
+	})), Match.tag("Convex", () => Effect.promise(() => runQuery(functionName, args))), Match.exhaustive);
 });
 const QueryRunner = Context.GenericTag("@confect/server/QueryRunner");
 const layer = (runQuery) => Layer.succeed(QueryRunner, make(runQuery));

package/dist/QueryRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryRunner.js","names":["Ref"],"sources":["../src/QueryRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericQueryCtx } from \"convex/server\";\nimport type { ParseResult } from \"effect\";\nimport { Context, Effect, Layer, Schema } from \"effect\";\n\nconst make =\n  (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  <Query extends Ref.AnyQuery>(\n    query: Query,\n    args: Ref.Args<Query>[\"Type\"],\n  ): Effect.Effect<Ref.Returns<Query>[\"Type\"], ParseResult.ParseError> =>\n    Effect.gen(function* () {\n      const function_ = Ref.getFunction(query);\n      const functionName = Ref.getConvexFunctionName(query);\n\n      const encodedArgs = yield* Schema.encode(function_.args)(args);\n      const encodedReturns = yield* Effect.promise(() =>\n        runQuery(functionName as any, encodedArgs),\n      );\n      return yield* Schema.decode(function_.returns)(encodedReturns);\n    });\n\nexport const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/QueryRunner\",\n);\nexport type QueryRunner = typeof QueryRunner.Identifier;\n\nexport const layer = (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  Layer.succeed(QueryRunner, make(runQuery));\n"],"mappings":";;;;;;;;;;AAKA,MAAM,QACH,cAEC,OACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,YAAYA,MAAI,YAAY,MAAM;CACxC,MAAM,eAAeA,MAAI,sBAAsB,MAAM;CAErD,MAAM,cAAc,OAAO,OAAO,OAAO,UAAU,KAAK,CAAC,KAAK;CAC9D,MAAM,iBAAiB,OAAO,OAAO,cACnC,SAAS,cAAqB,YAAY,CAC3C;AACD,QAAO,OAAO,OAAO,OAAO,UAAU,QAAQ,CAAC,eAAe;EAC9D;AAEN,MAAa,cAAc,QAAQ,WACjC,8BACD;AAGD,MAAa,SAAS,aACpB,MAAM,QAAQ,aAAa,KAAK,SAAS,CAAC"}
+{"version":3,"file":"QueryRunner.js","names":["Ref"],"sources":["../src/QueryRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericQueryCtx } from \"convex/server\";\nimport type { ParseResult } from \"effect\";\nimport { Context, Effect, Layer, Match, Schema } from \"effect\";\n\nconst make =\n  (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  <Query extends Ref.AnyQuery>(\n    query: Query,\n    args: Ref.Args<Query>,\n  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>\n    Effect.gen(function* () {\n      const functionSpec = Ref.getFunctionSpec(query);\n      const functionName = Ref.getConvexFunctionName(query);\n\n      return yield* Match.value(functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionSpec) =>\n          Effect.gen(function* () {\n            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(\n              args,\n            );\n            const encodedReturns = yield* Effect.promise(() =>\n              runQuery(functionName as any, encodedArgs),\n            );\n            return yield* Schema.decode(confectFunctionSpec.returns)(\n              encodedReturns,\n            );\n          }),\n        ),\n        Match.tag(\"Convex\", () =>\n          Effect.promise(() => runQuery(functionName as any, args as any)),\n        ),\n        Match.exhaustive,\n      );\n    });\n\nexport const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/QueryRunner\",\n);\nexport type QueryRunner = typeof QueryRunner.Identifier;\n\nexport const layer = (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  Layer.succeed(QueryRunner, make(runQuery));\n"],"mappings":";;;;;;;;;;AAKA,MAAM,QACH,cAEC,OACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,eAAeA,MAAI,gBAAgB,MAAM;CAC/C,MAAM,eAAeA,MAAI,sBAAsB,MAAM;AAErD,QAAO,OAAO,MAAM,MAAM,aAAa,mBAAmB,CAAC,KACzD,MAAM,IAAI,YAAY,wBACpB,OAAO,IAAI,aAAa;EACtB,MAAM,cAAc,OAAO,OAAO,OAAO,oBAAoB,KAAK,CAChE,KACD;EACD,MAAM,iBAAiB,OAAO,OAAO,cACnC,SAAS,cAAqB,YAAY,CAC3C;AACD,SAAO,OAAO,OAAO,OAAO,oBAAoB,QAAQ,CACtD,eACD;GACD,CACH,EACD,MAAM,IAAI,gBACR,OAAO,cAAc,SAAS,cAAqB,KAAY,CAAC,CACjE,EACD,MAAM,WACP;EACD;AAEN,MAAa,cAAc,QAAQ,WACjC,8BACD;AAGD,MAAa,SAAS,aACpB,MAAM,QAAQ,aAAa,KAAK,SAAS,CAAC"}

package/dist/RegisteredConvexFunction.d.ts

@@ -14,7 +14,7 @@ import { MutationRunner } from "./MutationRunner.js";
 import { QueryRunner } from "./QueryRunner.js";
 import { Scheduler as Scheduler$1 } from "./Scheduler.js";
 import { StorageReader as StorageReader$1, StorageWriter as StorageWriter$1 } from "./Storage.js";
-import { RegisteredFunction } from "./RegisteredFunction.js";
+import { Any } from "./RegisteredFunction.js";
 import { AnyWithProps as AnyWithProps$1 } from "./RegistryItem.js";
 import { Effect, Layer } from "effect";
 import * as _confect_core_Ref0 from "@confect/core/Ref";
@@ -31,9 +31,9 @@ declare namespace RegisteredConvexFunction_d_exports {
   export { MutationServices, make, mutationLayer };
 }
 declare const make: <Api_ extends AnyWithPropsWithRuntime<"Convex">>(api: Api_, {
-  function_,
+  functionSpec,
   handler
-}: AnyWithProps$1) => RegisteredFunction;
+}: AnyWithProps$1) => Any;
 declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
   table: <const TableName extends Name<IncludeSystemTables<Tables<Schema>>>>(tableName: TableName) => {
     readonly get: {
@@ -56,7 +56,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
 } | Auth$1 | {
   runAfter: <FuncRef extends convex_server0.SchedulableFunctionReference>(delay: effect_Duration0.Duration, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
   runAt: <FuncRef extends convex_server0.SchedulableFunctionReference>(dateTime: effect_DateTime0.DateTime, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Query>["Type"], effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>["Type"], effect_ParseResult0.ParseError>), never, never>;
+} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError>), never, never>;
 type MutationServices<Schema extends AnyWithProps> = DatabaseReader<Schema> | DatabaseWriter<Schema> | Auth$1 | Scheduler$1 | StorageReader$1 | StorageWriter$1 | QueryRunner | MutationRunner | MutationCtx<ToConvex<FromSchema<Schema>>>;
 //#endregion
 export { MutationServices, RegisteredConvexFunction_d_exports, make, mutationLayer };

package/dist/RegisteredConvexFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4Ba,IAAA,gBAAqB,uBAAA,YAChC,GAAA,EAAK,IAAA;EACL,SAAA;EAAA;AAAA,GAAwB,cAAA,KACvB,kBAAA;AAAA,cAuHU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,kBAAA,CAAA,QAAA,CAAA,UAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;KAmB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}
+{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba,IAAA,gBAAqB,uBAAA,YAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAiIU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,kBAAA,CAAA,QAAA,CAAA,UAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}

package/dist/RegisteredConvexFunction.js

@@ -1,5 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { layer } from "./Auth.js";
+import { make as make$1 } from "./ConvexConfigProvider.js";
 import { compileArgsSchema, compileReturnsSchema } from "./SchemaToValidator.js";
 import { layer as layer$1 } from "./DatabaseReader.js";
 import { layer as layer$2 } from "./DatabaseWriter.js";
@@ -18,31 +19,34 @@ var RegisteredConvexFunction_exports = /* @__PURE__ */ __exportAll({
 	make: () => make,
 	mutationLayer: () => mutationLayer
 });
-const make = (api, { function_, handler }) => Match.value(function_.runtimeAndFunctionType.functionType).pipe(Match.when("query", () => {
-	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => queryGeneric), Match.when("internal", () => internalQueryGeneric), Match.exhaustive)(queryFunction(api.databaseSchema, {
-		args: function_.args,
-		returns: function_.returns,
-		handler
-	}));
-}), Match.when("mutation", () => {
-	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => mutationGeneric), Match.when("internal", () => internalMutationGeneric), Match.exhaustive)(mutationFunction(api.databaseSchema, {
-		args: function_.args,
-		returns: function_.returns,
-		handler
-	}));
-}), Match.when("action", () => {
-	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(convexActionFunction(api.databaseSchema, {
-		args: function_.args,
-		returns: function_.returns,
-		handler
-	}));
+const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
+	const { functionVisibility, functionProvenance } = functionSpec;
+	return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(Match.when("query", () => {
+		return Match.value(functionVisibility).pipe(Match.when("public", () => queryGeneric), Match.when("internal", () => internalQueryGeneric), Match.exhaustive)(queryFunction(api.databaseSchema, {
+			args: functionProvenance.args,
+			returns: functionProvenance.returns,
+			handler
+		}));
+	}), Match.when("mutation", () => {
+		return Match.value(functionVisibility).pipe(Match.when("public", () => mutationGeneric), Match.when("internal", () => internalMutationGeneric), Match.exhaustive)(mutationFunction(api.databaseSchema, {
+			args: functionProvenance.args,
+			returns: functionProvenance.returns,
+			handler
+		}));
+	}), Match.when("action", () => {
+		return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(convexActionFunction(api.databaseSchema, {
+			args: functionProvenance.args,
+			returns: functionProvenance.returns,
+			handler
+		}));
+	}), Match.exhaustive);
 }), Match.exhaustive);
 const queryFunction = (databaseSchema, { args, returns, handler }) => ({
 	args: compileArgsSchema(args),
 	returns: compileReturnsSchema(returns),
-	handler: (ctx, actualArgs) => pipe(actualArgs, Schema.decode(args), Effect.orDie, Effect.andThen((decodedArgs) => pipe(handler(decodedArgs), Effect.provide(Layer.mergeAll(layer$1(databaseSchema, ctx.db), layer(ctx.auth), StorageReader$1.layer(ctx.storage), layer$4(ctx.runQuery), Layer.succeed(QueryCtx(), ctx))))), Effect.andThen((convexReturns) => Schema.encodeUnknown(returns)(convexReturns)), Effect.runPromise)
+	handler: (ctx, actualArgs) => pipe(actualArgs, Schema.decode(args), Effect.orDie, Effect.andThen((decodedArgs) => pipe(handler(decodedArgs), Effect.provide(Layer.mergeAll(layer$1(databaseSchema, ctx.db), layer(ctx.auth), StorageReader$1.layer(ctx.storage), layer$4(ctx.runQuery), Layer.succeed(QueryCtx(), ctx), Layer.setConfigProvider(make$1()))))), Effect.andThen((convexReturns) => Schema.encodeUnknown(returns)(convexReturns)), Effect.runPromise)
 });
-const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$1(schema, ctx.db), layer$2(schema, ctx.db), layer(ctx.auth), layer$5(ctx.scheduler), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), layer$4(ctx.runQuery), layer$3(ctx.runMutation), Layer.succeed(MutationCtx(), ctx));
+const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$1(schema, ctx.db), layer$2(schema, ctx.db), layer(ctx.auth), layer$5(ctx.scheduler), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), layer$4(ctx.runQuery), layer$3(ctx.runMutation), Layer.succeed(MutationCtx(), ctx), Layer.setConfigProvider(make$1()));
 const mutationFunction = (schema, { args, returns, handler }) => ({
 	args: compileArgsSchema(args),
 	returns: compileReturnsSchema(returns),
@@ -52,7 +56,7 @@ const convexActionFunction = (schema, { args, returns, handler }) => actionFunct
 	args,
 	returns,
 	handler,
-	createLayer: (ctx) => actionLayer(schema, ctx)
+	createLayer: (ctx) => Layer.mergeAll(actionLayer(schema, ctx), Layer.setConfigProvider(make$1()))
 });
 
 //#endregion

package/dist/RegisteredConvexFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport { Effect, Layer, Match, pipe, Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Auth from \"./Auth\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader, StorageWriter } from \"./Storage\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Convex\">>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.RegisteredFunction =>\n  Match.value(function_.runtimeAndFunctionType.functionType).pipe(\n    Match.when(\"query\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => queryGeneric),\n        Match.when(\"internal\", () => internalQueryGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        queryFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"mutation\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => mutationGeneric),\n        Match.when(\"internal\", () => internalMutationGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        mutationFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.when(\"action\", () => {\n      const genericFunction = Match.value(function_.functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        convexActionFunction(api.databaseSchema, {\n          args: function_.args,\n          returns: function_.returns,\n          handler,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | DatabaseReader.DatabaseReader<DatabaseSchema_>\n      | Auth.Auth\n      | StorageReader\n      | QueryRunner.QueryRunner\n      | QueryCtx.QueryCtx<\n          DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n        >\n    >;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) => RegisteredFunction.actionLayer(schema, ctx),\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA4BA,MAAa,QACX,KACA,EAAE,WAAW,cAEb,MAAM,MAAM,UAAU,uBAAuB,aAAa,CAAC,KACzD,MAAM,KAAK,eAAe;AAOxB,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,aAAa,EACxC,MAAM,KAAK,kBAAkB,qBAAqB,EAClD,MAAM,WACP,CAGC,cAAc,IAAI,gBAAgB;EAChC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;EACD,EACF,MAAM,KAAK,kBAAkB;AAO3B,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,gBAAgB,EAC3C,MAAM,KAAK,kBAAkB,wBAAwB,EACrD,MAAM,WACP,CAGC,iBAAiB,IAAI,gBAAgB;EACnC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;EACD,EACF,MAAM,KAAK,gBAAgB;AAOzB,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,qBAAqB,IAAI,gBAAgB;EACvC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,iBAQJ,gBACA,EACE,MACA,SACA,eAkBE;CACJ,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KAGA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,KACE,QAAQ,YAAY,EACpB,OAAO,QACL,MAAM,SACJC,QAAqB,gBAAgB,IAAI,GAAG,EAC5CC,MAAW,IAAI,KAAK,EACpBC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,QAAkB,IAAI,SAAS,EAC/B,MAAM,QACJC,UAEG,EACH,IACD,CACF,CACF,CACF,CACF,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAED,MAAa,iBACX,QACA,QAEA,MAAM,SACJJ,QAAqB,QAAQ,IAAI,GAAG,EACpCK,QAAqB,QAAQ,IAAI,GAAG,EACpCJ,MAAW,IAAI,KAAK,EACpBK,QAAgB,IAAI,UAAU,EAC9BJ,gBAAc,MAAM,IAAI,QAAQ,EAChCK,gBAAc,MAAM,IAAI,QAAQ,EAChCJ,QAAkB,IAAI,SAAS,EAC/BK,QAAqB,IAAI,YAAY,EACrC,MAAM,QACJC,aAEG,EACH,IACD,CACF;AAaH,MAAM,oBAQJ,QACA,EACE,MACA,SACA,eAME;CACJ,MAAMX,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,QAAQ,YAAY,CAAC,KAAK,OAAO,QAAQ,cAAc,QAAQ,IAAI,CAAC,CAAC,CACtE,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAED,MAAM,wBAQJ,QACA,EACE,MACA,SACA,cAaFW,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QAAQC,YAA+B,QAAQ,IAAI;CAClE,CAAC"}
+{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","ConvexConfigProvider.make","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport { Effect, Layer, Match, pipe, Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as Handler from \"./Handler\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader, StorageWriter } from \"./Storage\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Convex\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(\n        Match.when(\"query\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => queryGeneric),\n            Match.when(\"internal\", () => internalQueryGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            queryFunction(api.databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"mutation\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => mutationGeneric),\n            Match.when(\"internal\", () => internalMutationGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            mutationFunction(api.databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"action\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => actionGeneric),\n            Match.when(\"internal\", () => internalActionGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            convexActionFunction(api.databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | DatabaseReader.DatabaseReader<DatabaseSchema_>\n      | Auth.Auth\n      | StorageReader\n      | QueryRunner.QueryRunner\n      | QueryCtx.QueryCtx<\n          DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n        >\n    >;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        pipe(\n          handler(decodedArgs),\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n              Layer.setConfigProvider(ConvexConfigProvider.make()),\n            ),\n          ),\n        ),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n    Layer.setConfigProvider(ConvexConfigProvider.make()),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: Schema,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (a: Args) => Effect.Effect<Returns, E, MutationServices<Schema>>;\n  },\n) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(mutationLayer(schema, ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        Layer.setConfigProvider(ConvexConfigProvider.make()),\n      ),\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAEF,QAAO,MAAM,MAAM,aAAa,uBAAuB,aAAa,CAAC,KACnE,MAAM,KAAK,eAAe;AAOxB,SANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,aAAa,EACxC,MAAM,KAAK,kBAAkB,qBAAqB,EAClD,MAAM,WACP,CAGC,cAAc,IAAI,gBAAgB;GAChC,MAAM,mBAAmB;GACzB,SAAS,mBAAmB;GACnB;GACV,CAAC,CACH;GACD,EACF,MAAM,KAAK,kBAAkB;AAO3B,SANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,gBAAgB,EAC3C,MAAM,KAAK,kBAAkB,wBAAwB,EACrD,MAAM,WACP,CAGC,iBAAiB,IAAI,gBAAgB;GACnC,MAAM,mBAAmB;GACzB,SAAS,mBAAmB;GACnB;GACV,CAAC,CACH;GACD,EACF,MAAM,KAAK,gBAAgB;AAOzB,SANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,qBAAqB,IAAI,gBAAgB;GACvC,MAAM,mBAAmB;GACzB,SAAS,mBAAmB;GACnB;GACV,CAAC,CACH;GACD,EACF,MAAM,WACP;EACD,EACF,MAAM,WACP;AAEH,MAAM,iBAQJ,gBACA,EACE,MACA,SACA,eAkBE;CACJ,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KAGA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,KACE,QAAQ,YAAY,EACpB,OAAO,QACL,MAAM,SACJC,QAAqB,gBAAgB,IAAI,GAAG,EAC5CC,MAAW,IAAI,KAAK,EACpBC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,QAAkB,IAAI,SAAS,EAC/B,MAAM,QACJC,UAEG,EACH,IACD,EACD,MAAM,kBAAkBC,QAA2B,CAAC,CACrD,CACF,CACF,CACF,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAED,MAAa,iBACX,QACA,QAEA,MAAM,SACJL,QAAqB,QAAQ,IAAI,GAAG,EACpCM,QAAqB,QAAQ,IAAI,GAAG,EACpCL,MAAW,IAAI,KAAK,EACpBM,QAAgB,IAAI,UAAU,EAC9BL,gBAAc,MAAM,IAAI,QAAQ,EAChCM,gBAAc,MAAM,IAAI,QAAQ,EAChCL,QAAkB,IAAI,SAAS,EAC/BM,QAAqB,IAAI,YAAY,EACrC,MAAM,QACJC,aAEG,EACH,IACD,EACD,MAAM,kBAAkBL,QAA2B,CAAC,CACrD;AAaH,MAAM,oBAQJ,QACA,EACE,MACA,SACA,eAME;CACJ,MAAMP,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,QAAQ,YAAY,CAAC,KAAK,OAAO,QAAQ,cAAc,QAAQ,IAAI,CAAC,CAAC,CACtE,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAED,MAAM,wBAQJ,QACA,EACE,MACA,SACA,cAaFY,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,QAAQ,IAAI,EAC3C,MAAM,kBAAkBP,QAA2B,CAAC,CACrD;CACJ,CAAC"}

package/dist/RegisteredFunction.d.ts

@@ -13,15 +13,26 @@ import * as _confect_core_Ref0 from "@confect/core/Ref";
 import * as convex_server0 from "convex/server";
 import { DefaultFunctionArgs, FunctionVisibility, GenericActionCtx, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
 import * as convex_values0 from "convex/values";
+import { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import * as effect_Duration0 from "effect/Duration";
 import * as effect_DateTime0 from "effect/DateTime";
 import * as effect_ParseResult0 from "effect/ParseResult";
 
 //#region src/RegisteredFunction.d.ts
 declare namespace RegisteredFunction_d_exports {
-  export { ActionServices, RegisteredFunction, actionFunctionBase, actionLayer };
+  export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, actionFunctionBase, actionLayer };
 }
-type RegisteredFunction = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
+type Any = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
+type ConfectRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends DefaultFunctionArgs ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : never : never;
+type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends {
+  functionProvenance: {
+    _tag: "Convex";
+    _args: infer Args_ extends DefaultFunctionArgs;
+    _returns: infer Returns_;
+  };
+} ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : never : never;
+type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexRegisteredFunction<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectRegisteredFunction<FunctionSpec_> : never;
 declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({
   args,
   returns,
@@ -41,7 +52,7 @@ type ActionServices<DatabaseSchema_ extends AnyWithProps> = Scheduler$1 | Auth$1
 declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<Auth$1 | {
   runAfter: <FuncRef extends convex_server0.SchedulableFunctionReference>(delay: effect_Duration0.Duration, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
   runAt: <FuncRef extends convex_server0.SchedulableFunctionReference>(dateTime: effect_DateTime0.DateTime, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Query>["Type"], effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>["Type"], effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | StorageActionWriter$1 | (<Action extends _confect_core_Ref0.AnyAction>(action: Action, args: _confect_core_Ref0.Args<Action>["Type"]) => Effect.Effect<_confect_core_Ref0.Returns<Action>["Type"], effect_ParseResult0.ParseError>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
+} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | StorageActionWriter$1 | (<Action extends _confect_core_Ref0.AnyAction>(action: Action, args: _confect_core_Ref0.Args<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, effect_ParseResult0.ParseError>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
   vector: number[];
   limit?: number;
   filter?: (q: convex_server0.VectorFilterBuilder<convex_server0.DocumentByInfo<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>, convex_server0.NamedVectorIndex<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.FilterExpression<boolean>;
@@ -50,5 +61,5 @@ declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema
   _score: number;
 }[], never, never>), never, never>;
 //#endregion
-export { ActionServices, RegisteredFunction, RegisteredFunction_d_exports, actionFunctionBase, actionLayer };
+export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, RegisteredFunction_d_exports, actionFunctionBase, actionLayer };
 //# sourceMappingURL=RegisteredFunction.d.ts.map

package/dist/RegisteredFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;KAqBY,kBAAA,GACR,eAAA,CAAgB,kBAAA,EAAoB,mBAAA,SACpC,kBAAA,CAAmB,kBAAA,EAAoB,mBAAA,SACvC,gBAAA,CAAiB,kBAAA,EAAoB,mBAAA;AAAA,cAE5B,kBAAA,kBACI,YAAA,2BAEI,mBAAA;EAKnB,IAAA;EAAA,OAAA;EAAA,OAAA;EAAA;AAAA;EAMA,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,UAAA;EAC1B,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,aAAA;EAChC,OAAA,GAAU,CAAA,EAAG,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,CAAA,EAAG,CAAA;EAChD,WAAA,GACE,GAAA,EAAK,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAC3D,KAAA,CAAM,KAAA,CAAM,CAAA;AAAA;QAAD,cAAA,CAAA,kBAAA;;iBAKT,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAAS,UAAA,EAC3D,UAAA,KACX,OAAA,CAAQ,aAAA;AAAA;AAAA,KAeD,cAAA,yBACc,YAAA,IAEtB,WAAA,GACA,MAAA,GACA,eAAA,GACA,eAAA,GACA,qBAAA,GACA,WAAA,GACA,cAAA,GACA,YAAA,GACA,YAAA,CAA0B,UAAA,CAAqB,eAAA,KAC/C,SAAA,CACE,QAAA,CAAmB,UAAA,CAAqB,eAAA;AAAA,cAGjC,WAAA,2BACa,YAAA,EAExB,cAAA,EAAgB,eAAA,EAChB,GAAA,EAAK,gBAAA,CACH,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA,CAAA,MAAA;6BAAA,cAAA,CAAA,4BAAA"}
+{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;KAuBY,GAAA,GACR,eAAA,CAAgB,kBAAA,EAAoB,mBAAA,SACpC,kBAAA,CAAmB,kBAAA,EAAoB,mBAAA,SACvC,gBAAA,CAAiB,kBAAA,EAAoB,mBAAA;AAAA,KAEpC,yBAAA,uBACmB,YAAA,CAAa,YAAA,IAEnC,YAAA,CAAa,WAAA,CAAY,aAAA,8BACvB,mBAAA,GACE,sBAAA,CAAuB,eAAA,CACrB,aAAA,8CAEA,eAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA,MAEtC,sBAAA,CAAuB,eAAA,CACnB,aAAA,iDAEF,kBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA,MAEtC,sBAAA,CAAuB,eAAA,CACnB,aAAA,+CAEF,gBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,OAAA,CAAQ,YAAA,CAAa,cAAA,CAAe,aAAA;AAAA,KAKtC,wBAAA,uBACY,YAAA,CAAa,YAAA,IACjC,aAAA;EACF,kBAAA;IACE,IAAA;IACA,KAAA,sBAA2B,mBAAA;IAC3B,QAAA;EAAA;AAAA,IAGA,sBAAA,CAAuB,eAAA,CACrB,aAAA,8CAEA,eAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA,IAEF,sBAAA,CAAuB,eAAA,CACnB,aAAA,iDAEF,kBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA,IAEF,sBAAA,CAAuB,eAAA,CACnB,aAAA,+CAEF,gBAAA,CACE,YAAA,CAAa,qBAAA,CAAsB,aAAA,GACnC,KAAA,EACA,QAAA;AAAA,KAKA,kBAAA,uBACY,YAAA,CAAa,YAAA,IAEnC,aAAA,SAAsB,YAAA,CAAa,sBAAA,CACjC,aAAA,EACA,kBAAA,CAAmB,SAAA,IAEjB,wBAAA,CAAyB,aAAA,IACzB,aAAA,SAAsB,YAAA,CAAa,sBAAA,CAC/B,aAAA,EACA,kBAAA,CAAmB,UAAA,IAErB,yBAAA,CAA0B,aAAA;AAAA,cAGrB,kBAAA,kBACI,YAAA,2BAEI,mBAAA;EAKnB,IAAA;EAAA,OAAA;EAAA,OAAA;EAAA;AAAA;EAMA,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,UAAA;EAC1B,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,aAAA;EAChC,OAAA,GAAU,CAAA,EAAG,IAAA,KAAS,MAAA,CAAO,MAAA,CAAO,OAAA,EAAS,CAAA,EAAG,CAAA;EAChD,WAAA,GACE,GAAA,EAAK,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAC3D,KAAA,CAAM,KAAA,CAAM,CAAA;AAAA;QAAD,cAAA,CAAA,kBAAA;;iBAKT,gBAAA,CAAiB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAAS,UAAA,EAC3D,UAAA,KACX,OAAA,CAAQ,aAAA;AAAA;AAAA,KAeD,cAAA,yBACc,YAAA,IAEtB,WAAA,GACA,MAAA,GACA,eAAA,GACA,eAAA,GACA,qBAAA,GACA,WAAA,GACA,cAAA,GACA,YAAA,GACA,YAAA,CAA0B,UAAA,CAAqB,eAAA,KAC/C,SAAA,CACE,QAAA,CAAmB,UAAA,CAAqB,eAAA;AAAA,cAGjC,WAAA,2BACa,YAAA,EAExB,cAAA,EAAgB,eAAA,EAChB,GAAA,EAAK,gBAAA,CACH,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA,CAAA,MAAA;6BAAA,cAAA,CAAA,4BAAA"}

package/dist/RegisteredFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","StorageReader","StorageWriter","StorageActionWriter","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport { Effect, Layer, pipe, Schema } from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageActionWriter, StorageReader, StorageWriter } from \"./Storage\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type RegisteredFunction =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(createLayer(ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.Scheduler\n  | Auth.Auth\n  | StorageReader\n  | StorageWriter\n  | StorageActionWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    ActionRunner.layer(ctx.runAction),\n    VectorSearch.layer(ctx.vectorSearch),\n    Layer.succeed(\n      ActionCtx.ActionCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0BA,MAAa,sBAQX,EACA,MACA,SACA,SACA,mBAQK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,QAAQ,YAAY,CAAC,KAAK,OAAO,QAAQ,YAAY,IAAI,CAAC,CAAC,CAC5D,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,EACpBC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,sBAAoB,MAAM,IAAI,QAAQ,EACtCC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}
+{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","StorageReader","StorageWriter","StorageActionWriter","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport { Effect, Layer, pipe, Schema } from \"effect\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageActionWriter, StorageReader, StorageWriter } from \"./Storage\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends {\n  functionProvenance: {\n    _tag: \"Convex\";\n    _args: infer Args_ extends DefaultFunctionArgs;\n    _returns: infer Returns_;\n  };\n}\n  ? RuntimeAndFunctionType.GetFunctionType<\n      FunctionSpec_[\"runtimeAndFunctionType\"]\n    > extends \"query\"\n    ? RegisteredQuery<\n        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n        Args_,\n        Returns_\n      >\n    : RuntimeAndFunctionType.GetFunctionType<\n          FunctionSpec_[\"runtimeAndFunctionType\"]\n        > extends \"mutation\"\n      ? RegisteredMutation<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"action\"\n        ? RegisteredAction<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    pipe(\n      actualArgs,\n      Schema.decode(args),\n      Effect.orDie,\n      Effect.andThen((decodedArgs) =>\n        handler(decodedArgs).pipe(Effect.provide(createLayer(ctx))),\n      ),\n      Effect.andThen((convexReturns) =>\n        Schema.encodeUnknown(returns)(convexReturns),\n      ),\n      Effect.runPromise,\n    ),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.Scheduler\n  | Auth.Auth\n  | StorageReader\n  | StorageWriter\n  | StorageActionWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    ActionRunner.layer(ctx.runAction),\n    VectorSearch.layer(ctx.vectorSearch),\n    Layer.succeed(\n      ActionCtx.ActionCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;AA+GA,MAAa,sBAQX,EACA,MACA,SACA,SACA,mBAQK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,KACE,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,OACP,OAAO,SAAS,gBACd,QAAQ,YAAY,CAAC,KAAK,OAAO,QAAQ,YAAY,IAAI,CAAC,CAAC,CAC5D,EACD,OAAO,SAAS,kBACd,OAAO,cAAc,QAAQ,CAAC,cAAc,CAC7C,EACD,OAAO,WACR;CACJ;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,EACpBC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,gBAAc,MAAM,IAAI,QAAQ,EAChCC,sBAAoB,MAAM,IAAI,QAAQ,EACtCC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}

package/dist/RegisteredFunctions.d.ts

@@ -1,6 +1,6 @@
 import { AnyWithProps as AnyWithProps$1 } from "./Api.js";
+import { Any, RegisteredFunction } from "./RegisteredFunction.js";
 import { Impl } from "./Impl.js";
-import { RegisteredFunction } from "./RegisteredFunction.js";
 import { AnyWithProps as AnyWithProps$2 } from "./RegistryItem.js";
 import { Layer, Types } from "effect";
 import * as Spec from "@confect/core/Spec";
@@ -12,11 +12,11 @@ declare namespace RegisteredFunctions_d_exports {
   export { AnyWithProps, RegisteredFunctions, make };
 }
 type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
-type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer Function extends FunctionSpec.AnyWithProps ? FunctionSpec.RegisteredFunction<Function> : never } : never };
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never }> : { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never } : never };
 interface AnyWithProps {
-  readonly [key: string]: RegisteredFunction | AnyWithProps;
+  readonly [key: string]: Any | AnyWithProps;
 }
-declare const make: <Api_ extends AnyWithProps$1>(impl: Layer.Layer<Impl<Api_, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => RegisteredFunction) => Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Api_["spec"]>>>;
+declare const make: <Api_ extends AnyWithProps$1>(impl: Layer.Layer<Impl<Api_, "Finalized">>, makeRegisteredFunction: (api: Api_, registryItem: AnyWithProps$2) => Any) => Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Api_["spec"]>>>;
 //#endregion
 export { AnyWithProps, RegisteredFunctions, RegisteredFunctions_d_exports, make };
 //# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAYY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,SAAA,CAAU,MAAA,CAAO,KAAA,kCACf,SAAA,CAAU,YAAA,GACV,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,uBACP,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,iCAC+B,YAAA,CAAa,YAAA,GAC1C,YAAA,CAAa,kBAAA,CAAmB,QAAA,kCAKrB,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,iCAC+B,YAAA,CAAa,YAAA,GAC1C,YAAA,CAAa,kBAAA,CAAmB,QAAA;AAAA,UAM7B,YAAA;EAAA,UACL,GAAA,WAAc,kBAAA,GAAwC,YAAA;AAAA;AAAA,cAGrD,IAAA,gBAAqB,cAAA,EAChC,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,IAAA,CAAU,IAAA,iBAC5B,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,kBAAA,KAAqC,KAAA,CAAA,QAAA,CAAA,yBAAA,CAAA,IAAA,CAAA,MAAA,CAAA,IAAA"}
+{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAYY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,SAAA,CAAU,MAAA,CAAO,KAAA,kCACf,SAAA,CAAU,YAAA,GACV,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,uBACP,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA,kCAK3B,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA;AAAA,UAMnC,YAAA;EAAA,UACL,GAAA,WAAc,GAAA,GAAyB,YAAA;AAAA;AAAA,cAGtC,IAAA,gBAAqB,cAAA,EAChC,IAAA,EAAM,KAAA,CAAM,KAAA,CAAM,IAAA,CAAU,IAAA,iBAC5B,sBAAA,GACE,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,cAAA,KACX,GAAA,KAAsB,KAAA,CAAA,QAAA,CAAA,yBAAA,CAAA,IAAA,CAAA,MAAA,CAAA,IAAA"}

package/dist/RegisteredFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer } from \"effect\";\nimport { Effect, Match, Ref, type Types } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer Function extends FunctionSpec.AnyWithProps\n              ? FunctionSpec.RegisteredFunction<Function>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer Function extends FunctionSpec.AnyWithProps\n            ? FunctionSpec.RegisteredFunction<Function>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.RegisteredFunction | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.RegisteredFunction,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<\n            RegistryItem.AnyWithProps,\n            RegisteredFunction.RegisteredFunction\n          >(functionImplItems, RegistryItem.isRegistryItem, (registryItem) =>\n            makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n"],"mappings":";;;;;;;;;AAmDA,MAAa,QACX,MACA,2BAKA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA;CACxB,MAAM,oBAAoB,OAAO,IAAI,IAAI,SAAS;CAClD,MAAM,EAAE,KAAK,uBAAuB,OAAOC,MAA8B;AAEzE,QAAO,OAAO,MAAM,MAClB,mBACD,CAAC,KACA,MAAM,gBAAkE,EACxE,MAAM,KAAK,qBACT,OAAO,WAAW,wBAAwB,CAC3C,EACD,MAAM,KAAK,mBACT,OAAO,QACL,UAGE,mBAAmBC,iBAA8B,iBACjD,uBAAuB,KAAK,aAAa,CAC1C,CACF,CACF,EACD,MAAM,WACP;EACD,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAE,OAAO,QAAQ"}
+{"version":3,"file":"RegisteredFunctions.js","names":["Registry.Registry","Impl.Impl","RegistryItem.isRegistryItem"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer } from \"effect\";\nimport { Effect, Match, Ref, type Types } from \"effect\";\nimport type * as Api from \"./Api\";\nimport * as Impl from \"./Impl\";\nimport { mapLeaves } from \"./internal/utils\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? GroupSpec.Groups<Group> extends infer SubGroups extends\n        GroupSpec.AnyWithProps\n      ? Types.Simplify<\n          RegisteredFunctionsHelper<SubGroups> & {\n            [FunctionName in FunctionSpec.Name<\n              GroupSpec.Functions<Group>\n            >]: FunctionSpec.WithName<\n              GroupSpec.Functions<Group>,\n              FunctionName\n            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n              : never;\n          }\n        >\n      : {\n          [FunctionName in FunctionSpec.Name<\n            GroupSpec.Functions<Group>\n          >]: FunctionSpec.WithName<\n            GroupSpec.Functions<Group>,\n            FunctionName\n          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n            : never;\n        }\n    : never;\n};\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;\n}\n\nexport const make = <Api_ extends Api.AnyWithProps>(\n  impl: Layer.Layer<Impl.Impl<Api_, \"Finalized\">>,\n  makeRegisteredFunction: (\n    api: Api_,\n    registryItem: RegistryItem.AnyWithProps,\n  ) => RegisteredFunction.Any,\n) =>\n  Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    const functionImplItems = yield* Ref.get(registry);\n    const { api, finalizationStatus } = yield* Impl.Impl<Api_, \"Finalized\">();\n\n    return yield* Match.value(\n      finalizationStatus as Impl.FinalizationStatus,\n    ).pipe(\n      Match.withReturnType<Effect.Effect<RegisteredFunctions<Api_[\"spec\"]>>>(),\n      Match.when(\"Unfinalized\", () =>\n        Effect.dieMessage(\"Impl is not finalized\"),\n      ),\n      Match.when(\"Finalized\", () =>\n        Effect.succeed(\n          mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(\n            functionImplItems,\n            RegistryItem.isRegistryItem,\n            (registryItem) => makeRegisteredFunction(api, registryItem),\n          ) as RegisteredFunctions<Api_[\"spec\"]>,\n        ),\n      ),\n      Match.exhaustive,\n    );\n  }).pipe(Effect.provide(impl), Effect.runSync);\n"],"mappings":";;;;;;;;;AAmDA,MAAa,QACX,MACA,2BAKA,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAOA;CACxB,MAAM,oBAAoB,OAAO,IAAI,IAAI,SAAS;CAClD,MAAM,EAAE,KAAK,uBAAuB,OAAOC,MAA8B;AAEzE,QAAO,OAAO,MAAM,MAClB,mBACD,CAAC,KACA,MAAM,gBAAkE,EACxE,MAAM,KAAK,qBACT,OAAO,WAAW,wBAAwB,CAC3C,EACD,MAAM,KAAK,mBACT,OAAO,QACL,UACE,mBACAC,iBACC,iBAAiB,uBAAuB,KAAK,aAAa,CAC5D,CACF,CACF,EACD,MAAM,WACP;EACD,CAAC,KAAK,OAAO,QAAQ,KAAK,EAAE,OAAO,QAAQ"}

package/dist/RegisteredNodeFunction.d.ts

@@ -1,5 +1,5 @@
 import { AnyWithPropsWithRuntime } from "./Api.js";
-import { RegisteredFunction } from "./RegisteredFunction.js";
+import { Any } from "./RegisteredFunction.js";
 import { AnyWithProps } from "./RegistryItem.js";
 
 //#region src/RegisteredNodeFunction.d.ts
@@ -7,9 +7,9 @@ declare namespace RegisteredNodeFunction_d_exports {
   export { make };
 }
 declare const make: <Api_ extends AnyWithPropsWithRuntime<"Node">>(api: Api_, {
-  function_,
+  functionSpec,
   handler
-}: AnyWithProps) => RegisteredFunction;
+}: AnyWithProps) => Any;
 //#endregion
 export { RegisteredNodeFunction_d_exports, make };
 //# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAaa,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,SAAA;EAAA;AAAA,GAAwB,YAAA,KACvB,kBAAA"}
+{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAea,IAAA,gBAAqB,uBAAA,UAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,YAAA,KAC1B,GAAA"}

package/dist/RegisteredNodeFunction.js

@@ -6,13 +6,14 @@ import { NodeContext } from "@effect/platform-node";
 
 //#region src/RegisteredNodeFunction.ts
 var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const make = (api, { function_, handler }) => {
-	return Match.value(function_.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
-		args: function_.args,
-		returns: function_.returns,
+const make = (api, { functionSpec, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => handler), Match.tag("Confect", () => {
+	const { functionVisibility, functionProvenance } = functionSpec;
+	return Match.value(functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(api.databaseSchema, {
+		args: functionProvenance.args,
+		returns: functionProvenance.returns,
 		handler
 	}));
-};
+}), Match.exhaustive);
 const nodeActionFunction = (databaseSchema, { args, returns, handler }) => actionFunctionBase({
 	args,
 	returns,

package/dist/RegisteredNodeFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { function_, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.RegisteredFunction => {\n  const genericFunction = Match.value(function_.functionVisibility).pipe(\n    Match.when(\"public\", () => actionGeneric),\n    Match.when(\"internal\", () => internalActionGeneric),\n    Match.exhaustive,\n  );\n\n  return genericFunction(\n    nodeActionFunction(api.databaseSchema, {\n      args: function_.args,\n      returns: function_.returns,\n      handler,\n    }),\n  );\n};\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAaA,MAAa,QACX,KACA,EAAE,WAAW,cAC6B;AAO1C,QANwB,MAAM,MAAM,UAAU,mBAAmB,CAAC,KAChE,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,UAAU;EAChB,SAAS,UAAU;EACnB;EACD,CAAC,CACH;;AAGH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,cAcFA,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}
+{"version":3,"file":"RegisteredNodeFunction.js","names":["RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { NodeContext } from \"@effect/platform-node\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport { Layer, Match, type Schema } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\n\nexport const make = <Api_ extends Api.AnyWithPropsWithRuntime<\"Node\">>(\n  api: Api_,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      const genericFunction = Match.value(functionVisibility).pipe(\n        Match.when(\"public\", () => actionGeneric),\n        Match.when(\"internal\", () => internalActionGeneric),\n        Match.exhaustive,\n      );\n\n      return genericFunction(\n        nodeActionFunction(api.databaseSchema, {\n          args: functionProvenance.args,\n          returns: functionProvenance.returns,\n          handler: handler as Handler.AnyConfectProvenance,\n        }),\n      );\n    }),\n    Match.exhaustive,\n  );\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeContext.NodeContext\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeContext.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;AAeA,MAAa,QACX,KACA,EAAE,cAAc,cAEhB,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC3C,MAAM,IAAI,gBAAgB,QAAkC,EAC5D,MAAM,IAAI,iBAAiB;CACzB,MAAM,EAAE,oBAAoB,uBAC1B;AAQF,QANwB,MAAM,MAAM,mBAAmB,CAAC,KACtD,MAAM,KAAK,gBAAgB,cAAc,EACzC,MAAM,KAAK,kBAAkB,sBAAsB,EACnD,MAAM,WACP,CAGC,mBAAmB,IAAI,gBAAgB;EACrC,MAAM,mBAAmB;EACzB,SAAS,mBAAmB;EACnB;EACV,CAAC,CACH;EACD,EACF,MAAM,WACP;AAEH,MAAM,sBAQJ,gBACA,EACE,MACA,SACA,cAcFA,mBAAsC;CACpC;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,IAAI,EACnD,YAAY,MACb;CACJ,CAAC"}

package/dist/RegistryItem.d.ts

@@ -1,5 +1,5 @@
 import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { AnyWithProps as AnyWithProps$2, Handler } from "./Handler.js";
+import { Any, Handler } from "./Handler.js";
 import * as FunctionSpec from "@confect/core/FunctionSpec";
 
 //#region src/RegistryItem.d.ts
@@ -11,21 +11,21 @@ type TypeId = typeof TypeId;
 declare const isRegistryItem: (value: unknown) => value is AnyWithProps;
 interface RegistryItem<DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps> {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec_;
+  readonly functionSpec: FunctionSpec_;
   readonly handler: Handler<DatabaseSchema_, FunctionSpec_>;
 }
 interface AnyWithProps {
   readonly [TypeId]: TypeId;
-  readonly function_: FunctionSpec.AnyWithProps;
-  readonly handler: AnyWithProps$2;
+  readonly functionSpec: FunctionSpec.AnyWithProps;
+  readonly handler: Any;
 }
-declare const make: <DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps>({
-  function_,
+declare const make: ({
+  functionSpec,
   handler
 }: {
-  function_: FunctionSpec_;
-  handler: Handler<DatabaseSchema_, FunctionSpec_>;
-}) => RegistryItem<DatabaseSchema_, FunctionSpec_>;
+  functionSpec: FunctionSpec.AnyWithProps;
+  handler: AnyWithProps["handler"];
+}) => AnyWithProps;
 //#endregion
 export { AnyWithProps, RegistryItem, RegistryItem_d_exports, TypeId, isRegistryItem, make };
 //# sourceMappingURL=RegistryItem.d.ts.map

package/dist/RegistryItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,cAAA,GAAkB,KAAA,cAAiB,KAAA,IAAS,YAAA;AAAA,UAOxC,YAAA,yBACS,cAAA,wBACF,YAAA,CAAa,YAAA;EAAA,UAEzB,MAAA,GAAS,MAAA;EAAA,SACV,SAAA,EAAW,aAAA;EAAA,SACX,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA;AAAA,UAGpC,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,SAAA,EAAW,YAAA,CAAa,YAAA;EAAA,SACxB,OAAA,EAAS,cAAA;AAAA;AAAA,cAGP,IAAA,2BACa,cAAA,wBACF,YAAA,CAAa,YAAA;EACnC,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,aAAA;EACX,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA,MACxC,YAAA,CAAa,eAAA,EAAiB,aAAA"}
+{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,cAAA,GAAkB,KAAA,cAAiB,KAAA,IAAS,YAAA;AAAA,UAOxC,YAAA,yBACS,cAAA,wBACF,YAAA,CAAa,YAAA;EAAA,UAEzB,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,aAAA;EAAA,SACd,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA;AAAA,UAGpC,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,YAAA,CAAa,YAAA;EAAA,SAC3B,OAAA,EAAS,GAAA;AAAA;AAAA,cAGP,IAAA;EAAQ,YAAA;EAAA;AAAA;EAInB,YAAA,EAAc,YAAA,CAAa,YAAA;EAC3B,OAAA,EAAS,YAAA;AAAA,MACP,YAAA"}

package/dist/RegistryItem.js

@@ -10,8 +10,8 @@ var RegistryItem_exports = /* @__PURE__ */ __exportAll({
 const TypeId = "@confect/server/RegistryItem";
 const isRegistryItem = (value) => Predicate.hasProperty(value, TypeId);
 const RegistryItemProto = { [TypeId]: TypeId };
-const make = ({ function_, handler }) => Object.assign(Object.create(RegistryItemProto), {
-	function_,
+const make = ({ functionSpec, handler }) => Object.assign(Object.create(RegistryItemProto), {
+	functionSpec,
 	handler
 });
 

package/dist/RegistryItem.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItem.js","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { Predicate } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"@confect/server/RegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst RegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\nexport interface RegistryItem<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec_;\n  readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly function_: FunctionSpec.AnyWithProps;\n  readonly handler: Handler.AnyWithProps;\n}\n\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n>({\n  function_,\n  handler,\n}: {\n  function_: FunctionSpec_;\n  handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}): RegistryItem<DatabaseSchema_, FunctionSpec_> =>\n  Object.assign(Object.create(RegistryItemProto), {\n    function_,\n    handler,\n  });\n"],"mappings":";;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,kBAAkB,UAC7B,UAAU,YAAY,OAAO,OAAO;AAEtC,MAAM,oBAAoB,GACvB,SAAS,QACX;AAiBD,MAAa,QAGX,EACA,WACA,cAKA,OAAO,OAAO,OAAO,OAAO,kBAAkB,EAAE;CAC9C;CACA;CACD,CAAC"}
+{"version":3,"file":"RegistryItem.js","names":[],"sources":["../src/RegistryItem.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport { Predicate } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"@confect/server/RegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst RegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\nexport interface RegistryItem<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> {\n  readonly [TypeId]: TypeId;\n  readonly functionSpec: FunctionSpec_;\n  readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly functionSpec: FunctionSpec.AnyWithProps;\n  readonly handler: Handler.Any;\n}\n\nexport const make = ({\n  functionSpec,\n  handler,\n}: {\n  functionSpec: FunctionSpec.AnyWithProps;\n  handler: AnyWithProps[\"handler\"];\n}): AnyWithProps =>\n  Object.assign(Object.create(RegistryItemProto), {\n    functionSpec,\n    handler,\n  });\n"],"mappings":";;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,kBAAkB,UAC7B,UAAU,YAAY,OAAO,OAAO;AAEtC,MAAM,oBAAoB,GACvB,SAAS,QACX;AAiBD,MAAa,QAAQ,EACnB,cACA,cAKA,OAAO,OAAO,OAAO,OAAO,kBAAkB,EAAE;CAC9C;CACA;CACD,CAAC"}