@confect/server 9.0.0-next.8 → 9.0.0-next.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +28 -0
- package/dist/Auth.d.ts +1 -1
- package/dist/DatabaseReader.d.ts +16 -16
- package/dist/DatabaseSchema.d.ts +1 -1
- package/dist/DatabaseSchema.js.map +1 -1
- package/dist/DatabaseWriter.d.ts +4 -4
- package/dist/DatabaseWriter.d.ts.map +1 -1
- package/dist/QueryInitializer.d.ts +1 -1
- package/dist/QueryInitializer.d.ts.map +1 -1
- package/dist/RegisteredConvexFunction.d.ts +11 -11
- package/dist/RegisteredConvexFunction.d.ts.map +1 -1
- package/dist/RegisteredFunction.d.ts +2 -2
- package/dist/RegisteredFunction.d.ts.map +1 -1
- package/dist/StorageActionWriter.d.ts +1 -1
- package/package.json +2 -2
- package/src/DatabaseSchema.ts +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,33 @@
|
|
|
1
1
|
# @confect/server
|
|
2
2
|
|
|
3
|
+
## 9.0.0-next.9
|
|
4
|
+
|
|
5
|
+
### Major Changes
|
|
6
|
+
|
|
7
|
+
- 4894959: Make Node-runtime functions first-class and remove the separate `node` namespace.
|
|
8
|
+
|
|
9
|
+
A function group's runtime is now declared solely by its spec — `GroupSpec.makeNode()` for a Node action group, `GroupSpec.make()` for a Convex group — exactly like vanilla Convex's per-file `"use node"` directive. The `confect/node/` directory is no longer special: Node specs/impls are ordinary colocated `.spec.ts`/`.impl.ts` pairs that can live anywhere in `confect/`, and codegen emits the `"use node"` directive into the generated `convex/` module based on the spec. This is safe because v9's per-group registries already isolate each Convex function's bundle from every other group's impl, so Node-only code can no longer leak into a Convex-runtime bundle regardless of namespace.
|
|
10
|
+
|
|
11
|
+
### Why
|
|
12
|
+
|
|
13
|
+
The `node` namespace existed only because the pre-v9 architecture aggregated every function's impl into one module that all generated `convex/` modules imported; Node functions had to be quarantined into a separate spec/impl/registry tree so Convex-runtime functions wouldn't transitively import Node-only code. v9's per-group isolation removed that constraint, so the namespace was no longer load-bearing — only ergonomic overhead that diverged from vanilla Convex (which identifies Node modules per-file, with no directory requirement).
|
|
14
|
+
|
|
15
|
+
### Breaking changes
|
|
16
|
+
- **API namespace removed.** A Node group at `confect/email.spec.ts` is now referenced as `refs.public.email.send` instead of `refs.public.node.email.send`. Node groups are ordinary groups in the refs tree, nesting preserved like any other group.
|
|
17
|
+
- **Generated layout changed.** Node modules are emitted at `convex/<path>.ts` (carrying `"use node"`) instead of `convex/node/<path>.ts`, and their registries at `confect/_generated/registeredFunctions/<path>.ts`. The single assembled `confect/_generated/spec.ts` now contains every group regardless of runtime; `confect/_generated/nodeSpec.ts` is no longer generated (codegen deletes any stale copy on upgrade).
|
|
18
|
+
- **`@confect/core` API.** Removed `Spec.makeNode`, `Spec.merge`, and `Spec.isConvexSpec`/`Spec.isNodeSpec`. `Spec` is now a single mixed-runtime container (`Spec.make()` accepts groups of any runtime). `Refs.make(spec)` takes a single argument (the unified spec) instead of `(convexSpec, nodeSpec)`. `GroupSpec.makeNode()`/`makeNodeAt()` and `FunctionSpec.publicNodeAction()`/`internalNodeAction()` are unchanged; `GroupSpec` subgroups may now be of any runtime (a group is just a namespace for its children).
|
|
19
|
+
|
|
20
|
+
### Migration
|
|
21
|
+
1. Move any `confect/node/<path>.spec.ts`/`.impl.ts` files to wherever you want them under `confect/` (e.g. `confect/<path>.spec.ts`); the `node/` directory has no special meaning anymore. Their specs already use `GroupSpec.makeNode()`, so no spec-body change is needed — only fix the impl's relative import of `_generated/schema` if its depth changed.
|
|
22
|
+
2. Update call sites to drop the `node` segment: `refs.public.node.<group>.<fn>` → `refs.public.<group>.<fn>`.
|
|
23
|
+
3. Replace `Refs.make(spec, nodeSpec)` with `Refs.make(spec)` (codegen does this for `_generated/refs.ts` automatically).
|
|
24
|
+
4. Run `confect codegen`. The `convex/` tree and `confect/_generated/` are re-emitted; the stale `_generated/nodeSpec.ts` is removed.
|
|
25
|
+
|
|
26
|
+
### Patch Changes
|
|
27
|
+
|
|
28
|
+
- Updated dependencies [4894959]
|
|
29
|
+
- @confect/core@9.0.0-next.9
|
|
30
|
+
|
|
3
31
|
## 9.0.0-next.8
|
|
4
32
|
|
|
5
33
|
### Patch Changes
|
package/dist/Auth.d.ts
CHANGED
|
@@ -17,7 +17,7 @@ declare const Auth_base: effect_Context0.TagClass<Auth, "@confect/server/Auth",
|
|
|
17
17
|
}> & {
|
|
18
18
|
use: <X>(body: (_: {
|
|
19
19
|
getUserIdentity: Effect.Effect<convex_server0.UserIdentity, NoUserIdentityFoundError, never>;
|
|
20
|
-
}) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E,
|
|
20
|
+
}) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Auth | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, Auth> : Effect.Effect<X, never, Auth>;
|
|
21
21
|
};
|
|
22
22
|
declare class Auth extends Auth_base {}
|
|
23
23
|
declare const layer: (auth: Auth$1) => Layer.Layer<Auth, never, never>;
|
package/dist/DatabaseReader.d.ts
CHANGED
|
@@ -110,7 +110,7 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
|
|
|
110
110
|
sha256: convex_values0.VString<string, "required">;
|
|
111
111
|
size: convex_values0.VFloat64<number, "required">;
|
|
112
112
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
113
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"],
|
|
113
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
|
|
114
114
|
<IndexName extends keyof (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
115
115
|
name: typeof effect_Schema0.String;
|
|
116
116
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
@@ -1100,7 +1100,7 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
|
|
|
1100
1100
|
};
|
|
1101
1101
|
};
|
|
1102
1102
|
declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
|
|
1103
|
-
table: <const TableName extends "
|
|
1103
|
+
table: <const TableName extends "_scheduled_functions" | "_storage" | Name<Tables<DatabaseSchema_>>>(tableName: TableName) => {
|
|
1104
1104
|
readonly get: {
|
|
1105
1105
|
(id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<(TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
1106
1106
|
name: typeof effect_Schema0.String;
|
|
@@ -1191,7 +1191,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
1191
1191
|
sha256: convex_values0.VString<string, "required">;
|
|
1192
1192
|
size: convex_values0.VFloat64<number, "required">;
|
|
1193
1193
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
1194
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"],
|
|
1194
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
|
|
1195
1195
|
<IndexName extends keyof (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
1196
1196
|
name: typeof effect_Schema0.String;
|
|
1197
1197
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
@@ -1281,7 +1281,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
1281
1281
|
sha256: convex_values0.VString<string, "required">;
|
|
1282
1282
|
size: convex_values0.VFloat64<number, "required">;
|
|
1283
1283
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
1284
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<Tables<DatabaseSchema_
|
|
1284
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<SystemTables | Tables<DatabaseSchema_>>>, TableName, (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
1285
1285
|
name: typeof effect_Schema0.String;
|
|
1286
1286
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
1287
1287
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -1640,7 +1640,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
1640
1640
|
sha256: convex_values0.VString<string, "required">;
|
|
1641
1641
|
size: convex_values0.VFloat64<number, "required">;
|
|
1642
1642
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
1643
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
1643
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
1644
1644
|
name: typeof effect_Schema0.String;
|
|
1645
1645
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
1646
1646
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -2088,7 +2088,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
2088
2088
|
sha256: convex_values0.VString<string, "required">;
|
|
2089
2089
|
size: convex_values0.VFloat64<number, "required">;
|
|
2090
2090
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
2091
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
2091
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
2092
2092
|
name: typeof effect_Schema0.String;
|
|
2093
2093
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
2094
2094
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -2180,7 +2180,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
2180
2180
|
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>, TableName>;
|
|
2181
2181
|
};
|
|
2182
2182
|
}, {
|
|
2183
|
-
table: <const TableName extends "
|
|
2183
|
+
table: <const TableName extends "_scheduled_functions" | "_storage" | Name<Tables<DatabaseSchema_>>>(tableName: TableName) => {
|
|
2184
2184
|
readonly get: {
|
|
2185
2185
|
(id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<(TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
2186
2186
|
name: typeof effect_Schema0.String;
|
|
@@ -2271,7 +2271,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
2271
2271
|
sha256: convex_values0.VString<string, "required">;
|
|
2272
2272
|
size: convex_values0.VFloat64<number, "required">;
|
|
2273
2273
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
2274
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"],
|
|
2274
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
|
|
2275
2275
|
<IndexName extends keyof (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
2276
2276
|
name: typeof effect_Schema0.String;
|
|
2277
2277
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
@@ -2361,7 +2361,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
2361
2361
|
sha256: convex_values0.VString<string, "required">;
|
|
2362
2362
|
size: convex_values0.VFloat64<number, "required">;
|
|
2363
2363
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
2364
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<Tables<DatabaseSchema_
|
|
2364
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<SystemTables | Tables<DatabaseSchema_>>>, TableName, (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
2365
2365
|
name: typeof effect_Schema0.String;
|
|
2366
2366
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
2367
2367
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -2720,7 +2720,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
2720
2720
|
sha256: convex_values0.VString<string, "required">;
|
|
2721
2721
|
size: convex_values0.VFloat64<number, "required">;
|
|
2722
2722
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
2723
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
2723
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
2724
2724
|
name: typeof effect_Schema0.String;
|
|
2725
2725
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
2726
2726
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -3168,7 +3168,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
3168
3168
|
sha256: convex_values0.VString<string, "required">;
|
|
3169
3169
|
size: convex_values0.VFloat64<number, "required">;
|
|
3170
3170
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
3171
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
3171
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
3172
3172
|
name: typeof effect_Schema0.String;
|
|
3173
3173
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
3174
3174
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -3262,7 +3262,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
|
|
|
3262
3262
|
}>;
|
|
3263
3263
|
type DatabaseReader<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof DatabaseReader<DatabaseSchema_>>["Identifier"];
|
|
3264
3264
|
declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
|
|
3265
|
-
table: <const TableName extends "
|
|
3265
|
+
table: <const TableName extends "_scheduled_functions" | "_storage" | Name<Tables<DatabaseSchema_>>>(tableName: TableName) => {
|
|
3266
3266
|
readonly get: {
|
|
3267
3267
|
(id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<(TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
3268
3268
|
name: typeof effect_Schema0.String;
|
|
@@ -3353,7 +3353,7 @@ declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Data
|
|
|
3353
3353
|
sha256: convex_values0.VString<string, "required">;
|
|
3354
3354
|
size: convex_values0.VFloat64<number, "required">;
|
|
3355
3355
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
3356
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"],
|
|
3356
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
|
|
3357
3357
|
<IndexName extends keyof (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
3358
3358
|
name: typeof effect_Schema0.String;
|
|
3359
3359
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
@@ -3443,7 +3443,7 @@ declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Data
|
|
|
3443
3443
|
sha256: convex_values0.VString<string, "required">;
|
|
3444
3444
|
size: convex_values0.VFloat64<number, "required">;
|
|
3445
3445
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
3446
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<Tables<DatabaseSchema_
|
|
3446
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<SystemTables | Tables<DatabaseSchema_>>>, TableName, (TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
3447
3447
|
name: typeof effect_Schema0.String;
|
|
3448
3448
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
3449
3449
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -3802,7 +3802,7 @@ declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Data
|
|
|
3802
3802
|
sha256: convex_values0.VString<string, "required">;
|
|
3803
3803
|
size: convex_values0.VFloat64<number, "required">;
|
|
3804
3804
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
3805
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
3805
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
3806
3806
|
name: typeof effect_Schema0.String;
|
|
3807
3807
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
3808
3808
|
scheduledTime: typeof effect_Schema0.Number;
|
|
@@ -4250,7 +4250,7 @@ declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Data
|
|
|
4250
4250
|
sha256: convex_values0.VString<string, "required">;
|
|
4251
4251
|
size: convex_values0.VFloat64<number, "required">;
|
|
4252
4252
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
4253
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<Tables<DatabaseSchema_
|
|
4253
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<SystemTables | Tables<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<Tables<DatabaseSchema_>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", effect_Schema0.Struct<{
|
|
4254
4254
|
name: typeof effect_Schema0.String;
|
|
4255
4255
|
args: effect_Schema0.Array$<typeof effect_Schema0.Any>;
|
|
4256
4256
|
scheduledTime: typeof effect_Schema0.Number;
|
package/dist/DatabaseSchema.d.ts
CHANGED
|
@@ -13,7 +13,7 @@ declare const isDatabaseSchema: (u: unknown) => u is Any;
|
|
|
13
13
|
/**
|
|
14
14
|
* A schema definition holding a record of bound `Table`s keyed by table
|
|
15
15
|
* name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;
|
|
16
|
-
* laziness
|
|
16
|
+
* laziness lives entirely on each `Table` (its `Fields`, `Doc`, and
|
|
17
17
|
* `tableDefinition` are lazy memoised getters), so this layer is a plain
|
|
18
18
|
* record indirection with no module-loading or async machinery.
|
|
19
19
|
*/
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"DatabaseSchema.js","names":[],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\";\nimport type * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition holding a record of bound `Table`s keyed by table\n * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;\n * laziness
|
|
1
|
+
{"version":3,"file":"DatabaseSchema.js","names":[],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import * as Predicate from \"effect/Predicate\";\nimport type * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition holding a record of bound `Table`s keyed by table\n * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;\n * laziness lives entirely on each `Table` (its `Fields`, `Doc`, and\n * `tableDefinition` are lazy memoised getters), so this layer is a plain\n * record indirection with no module-loading or async machinery.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n readonly [TypeId]: TypeId;\n readonly tables: {\n readonly [TableName in Table.Name<Tables_>]: Table.WithName<\n Tables_,\n TableName\n >;\n };\n}\n\nexport interface AnyWithProps {\n readonly [TypeId]: TypeId;\n readonly tables: Record<string, Table.AnyWithProps>;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n Tables<DatabaseSchema_>\n> &\n string;\n\nexport type TableWithName<\n DatabaseSchema_ extends AnyWithProps,\n TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;\n\n/**\n * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty\n * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from\n * the value record's values, so codegen-emitted calls of the form\n * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit\n * type argument.\n *\n * Invariant: each record **key must equal its value's `tableName`**. The\n * record is stored verbatim and later read by key (`databaseSchema.tables[\n * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges\n * from the bound table's name would make those lookups silently miss. The\n * type signature does not enforce this — codegen upholds it by deriving both\n * the key and the table name from the same filename (and the shorthand\n * `{ notes, tags, users }` form it emits makes them identical by\n * construction). Hand-written calls must preserve it.\n */\nexport const make = <\n const TablesRecord extends Record<string, Table.AnyWithProps>,\n>(\n tables: TablesRecord,\n): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({\n [TypeId]: TypeId,\n tables: tables as unknown as DatabaseSchema<\n TablesRecord[keyof TablesRecord]\n >[\"tables\"],\n});\n"],"mappings":";;;;;;;;;AAGA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;;;;;;;;;;;;;;;;;AAqDlC,MAAa,QAGX,YACsD;EACrD,SAAS;CACF;CAGT"}
|
package/dist/DatabaseWriter.d.ts
CHANGED
|
@@ -15,7 +15,7 @@ declare namespace DatabaseWriter_d_exports {
|
|
|
15
15
|
declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => {
|
|
16
16
|
table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
|
|
17
17
|
insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
|
|
18
|
-
patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void,
|
|
18
|
+
patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
|
|
19
19
|
replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, DocumentEncodeError, never>;
|
|
20
20
|
delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
|
|
21
21
|
};
|
|
@@ -23,14 +23,14 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
|
|
|
23
23
|
declare const DatabaseWriter: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
|
|
24
24
|
table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
|
|
25
25
|
insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
|
|
26
|
-
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void,
|
|
26
|
+
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
|
|
27
27
|
replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
|
|
28
28
|
delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
|
|
29
29
|
};
|
|
30
30
|
}, {
|
|
31
31
|
table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
|
|
32
32
|
insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
|
|
33
|
-
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void,
|
|
33
|
+
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
|
|
34
34
|
replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
|
|
35
35
|
delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
|
|
36
36
|
};
|
|
@@ -39,7 +39,7 @@ type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
|
|
|
39
39
|
declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
|
|
40
40
|
table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
|
|
41
41
|
insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
|
|
42
|
-
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void,
|
|
42
|
+
patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
|
|
43
43
|
replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
|
|
44
44
|
delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
|
|
45
45
|
};
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;;;cAqBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAKH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,
|
|
1
|
+
{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;;;cAqBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAKH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,mBAAA,GAAA,cAAA,GAAA,mBAAA;kBAqCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCAjHrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAuHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA/H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}
|
|
@@ -25,7 +25,7 @@ type QueryInitializer<DataModel_ extends AnyWithProps$2, TableName extends Table
|
|
|
25
25
|
readonly search: <IndexName extends keyof SearchIndexes<_ConvexTableInfo>>(indexName: IndexName, searchFilter: (q: SearchFilterBuilder<DocumentByInfo<_ConvexTableInfo>, NamedSearchIndex<_ConvexTableInfo, IndexName>>) => SearchFilter) => OrderedQuery$1<_TableInfo, TableName>;
|
|
26
26
|
};
|
|
27
27
|
declare const make: <Tables extends AnyWithProps, TableName extends Name<Tables>>(tableName: TableName, convexDatabaseReader: BaseDatabaseReader<ToConvex<FromTables<Tables>>>, table: WithName<Tables, TableName>) => QueryInitializer<DataModel<Tables>, TableName, TableInfoWithName<DataModel<Tables>, TableName>, TableInfoWithName_<DataModel<Tables>, TableName>>;
|
|
28
|
-
declare const getById: <Tables extends AnyWithProps, TableName extends Name<Tables>>(tableName: TableName, convexDatabaseReader: BaseDatabaseReader<ToConvex<FromTables<Tables>>>, table: WithName<Tables, TableName>) => (id: GenericId<TableName>) => Effect.Effect<any,
|
|
28
|
+
declare const getById: <Tables extends AnyWithProps, TableName extends Name<Tables>>(tableName: TableName, convexDatabaseReader: BaseDatabaseReader<ToConvex<FromTables<Tables>>>, table: WithName<Tables, TableName>) => (id: GenericId<TableName>) => Effect.Effect<any, DocumentDecodeError | GetByIdFailure, never>;
|
|
29
29
|
declare const GetByIdFailure_base: Schema.TaggedErrorClass<GetByIdFailure, "GetByIdFailure", {
|
|
30
30
|
readonly _tag: Schema.tag<"GetByIdFailure">;
|
|
31
31
|
} & {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"QueryInitializer.d.ts","names":[],"sources":["../src/QueryInitializer.ts"],"mappings":";;;;;;;;;;;;;;;KAiCK,gBAAA,oBACgB,cAAA,oBACD,UAAA,CAAqB,UAAA,4BACd,gBAAA,qBACN,cAAA;EAAA,SAEV,GAAA;IAAA,CAEL,EAAA,EAAI,SAAA,CAAU,SAAA,IACb,MAAA,CAAO,MAAA,CACR,UAAA,cACA,mBAAA,GAA+B,cAAA;IAAA,yBAER,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,KACR,gBAAA,EAAkB,oBAAA,CACnB,QAAA,CAAmB,UAAA,GACnB,SAAA,EACA,OAAA,CAAQ,gBAAA,EAAkB,SAAA,KAE3B,MAAA,CAAO,MAAA,CACR,UAAA,cACA,mBAAA,GAA+B,iBAAA;EAAA;EAAA,SAG1B,KAAA;IAAA,yBACkB,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,EACX,UAAA,IACE,CAAA,EAAG,iBAAA,CACD,UAAA,oBACA,UAAA,CAAW,gBAAA,EAAkB,SAAA,OAE5B,UAAA,EACL,KAAA,oBACC,cAAA,CAA0B,UAAA,EAAY,SAAA;IAAA,yBAChB,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,EACX,KAAA,oBACC,cAAA,CAA0B,UAAA,EAAY,SAAA;EAAA;EAAA,SAElC,MAAA,2BAAiC,aAAA,CAAc,gBAAA,GACtD,SAAA,EAAW,SAAA,EACX,YAAA,GACE,CAAA,EAAG,mBAAA,CACD,cAAA,CAAe,gBAAA,GACf,gBAAA,CAAiB,gBAAA,EAAkB,SAAA,OAElC,YAAA,KACF,cAAA,CAA0B,UAAA,EAAY,SAAA;AAAA;AAAA,cAGhC,IAAA,kBACI,YAAA,oBACG,IAAA,CAAW,MAAA,GAE7B,SAAA,EAAW,SAAA,EACX,oBAAA,EAAsB,kBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAE1C,KAAA,EAAO,QAAA,CAAe,MAAA,EAAQ,SAAA,MAC7B,gBAAA,CACD,SAAA,CAAoB,MAAA,GACpB,SAAA,EACA,iBAAA,CAA4B,SAAA,CAAoB,MAAA,GAAS,SAAA,GACzD,kBAAA,CAA6B,SAAA,CAAoB,MAAA,GAAS,SAAA;AAAA,cAmL/C,OAAA,kBACK,YAAA,oBAAsC,IAAA,CAAW,MAAA,GAC/D,SAAA,EAAW,SAAA,EACX,oBAAA,EAAsB,kBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAE1C,KAAA,EAAO,QAAA,CAAe,MAAA,EAAQ,SAAA,OAE/B,EAAA,EAAI,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA,MAAA,
|
|
1
|
+
{"version":3,"file":"QueryInitializer.d.ts","names":[],"sources":["../src/QueryInitializer.ts"],"mappings":";;;;;;;;;;;;;;;KAiCK,gBAAA,oBACgB,cAAA,oBACD,UAAA,CAAqB,UAAA,4BACd,gBAAA,qBACN,cAAA;EAAA,SAEV,GAAA;IAAA,CAEL,EAAA,EAAI,SAAA,CAAU,SAAA,IACb,MAAA,CAAO,MAAA,CACR,UAAA,cACA,mBAAA,GAA+B,cAAA;IAAA,yBAER,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,KACR,gBAAA,EAAkB,oBAAA,CACnB,QAAA,CAAmB,UAAA,GACnB,SAAA,EACA,OAAA,CAAQ,gBAAA,EAAkB,SAAA,KAE3B,MAAA,CAAO,MAAA,CACR,UAAA,cACA,mBAAA,GAA+B,iBAAA;EAAA;EAAA,SAG1B,KAAA;IAAA,yBACkB,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,EACX,UAAA,IACE,CAAA,EAAG,iBAAA,CACD,UAAA,oBACA,UAAA,CAAW,gBAAA,EAAkB,SAAA,OAE5B,UAAA,EACL,KAAA,oBACC,cAAA,CAA0B,UAAA,EAAY,SAAA;IAAA,yBAChB,OAAA,CAAQ,gBAAA,GAC/B,SAAA,EAAW,SAAA,EACX,KAAA,oBACC,cAAA,CAA0B,UAAA,EAAY,SAAA;EAAA;EAAA,SAElC,MAAA,2BAAiC,aAAA,CAAc,gBAAA,GACtD,SAAA,EAAW,SAAA,EACX,YAAA,GACE,CAAA,EAAG,mBAAA,CACD,cAAA,CAAe,gBAAA,GACf,gBAAA,CAAiB,gBAAA,EAAkB,SAAA,OAElC,YAAA,KACF,cAAA,CAA0B,UAAA,EAAY,SAAA;AAAA;AAAA,cAGhC,IAAA,kBACI,YAAA,oBACG,IAAA,CAAW,MAAA,GAE7B,SAAA,EAAW,SAAA,EACX,oBAAA,EAAsB,kBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAE1C,KAAA,EAAO,QAAA,CAAe,MAAA,EAAQ,SAAA,MAC7B,gBAAA,CACD,SAAA,CAAoB,MAAA,GACpB,SAAA,EACA,iBAAA,CAA4B,SAAA,CAAoB,MAAA,GAAS,SAAA,GACzD,kBAAA,CAA6B,SAAA,CAAoB,MAAA,GAAS,SAAA;AAAA,cAmL/C,OAAA,kBACK,YAAA,oBAAsC,IAAA,CAAW,MAAA,GAC/D,SAAA,EAAW,SAAA,EACX,oBAAA,EAAsB,kBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,MAAA,KAE1C,KAAA,EAAO,QAAA,CAAe,MAAA,EAAQ,SAAA,OAE/B,EAAA,EAAI,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA,MAAA,mBAAA,GAAA,cAAA;AAAA,cAOrB,mBAAA;;;;;;cAEO,cAAA,SAAuB,mBAAA;EAAA,IAOrB,OAAA,CAAA;AAAA;AAAA,cAOd,sBAAA;;;;;;;cAEY,iBAAA,SAA0B,sBAAA;EAAA,IAQxB,OAAA,CAAA;AAAA"}
|
|
@@ -36,11 +36,8 @@ declare const make: (databaseSchema: AnyWithProps, {
|
|
|
36
36
|
functionSpec,
|
|
37
37
|
handler
|
|
38
38
|
}: AnyWithProps$1) => Any;
|
|
39
|
-
declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<(<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | {
|
|
40
|
-
|
|
41
|
-
runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
|
|
42
|
-
} | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
|
|
43
|
-
table: <const TableName extends "_storage" | "_scheduled_functions" | Name<Tables<Schema>>>(tableName: TableName) => {
|
|
39
|
+
declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<Auth$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
|
|
40
|
+
table: <const TableName extends "_scheduled_functions" | "_storage" | Name<Tables<Schema>>>(tableName: TableName) => {
|
|
44
41
|
readonly get: {
|
|
45
42
|
(id: convex_values0.GenericId<TableName>): Effect.Effect<(TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
|
|
46
43
|
name: typeof Schema.String;
|
|
@@ -131,7 +128,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
|
|
|
131
128
|
sha256: convex_values0.VString<string, "required">;
|
|
132
129
|
size: convex_values0.VFloat64<number, "required">;
|
|
133
130
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
134
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"],
|
|
131
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["document"], DocumentDecodeError | GetByIdFailure, never>;
|
|
135
132
|
<IndexName extends keyof (TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
|
|
136
133
|
name: typeof Schema.String;
|
|
137
134
|
args: Schema.Array$<typeof Schema.Any>;
|
|
@@ -221,7 +218,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
|
|
|
221
218
|
sha256: convex_values0.VString<string, "required">;
|
|
222
219
|
size: convex_values0.VFloat64<number, "required">;
|
|
223
220
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
224
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<Tables<Schema
|
|
221
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<SystemTables | Tables<Schema>>>, TableName, (TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
|
|
225
222
|
name: typeof Schema.String;
|
|
226
223
|
args: Schema.Array$<typeof Schema.Any>;
|
|
227
224
|
scheduledTime: typeof Schema.Number;
|
|
@@ -580,7 +577,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
|
|
|
580
577
|
sha256: convex_values0.VString<string, "required">;
|
|
581
578
|
size: convex_values0.VFloat64<number, "required">;
|
|
582
579
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
583
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<Tables<Schema
|
|
580
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedIndex<TableInfoWithName<DataModel<SystemTables | Tables<Schema>>, TableName>, IndexName>, 0>) => convex_server0.IndexRange) | undefined, order?: "asc" | "desc"): OrderedQuery$1<TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
|
|
584
581
|
name: typeof Schema.String;
|
|
585
582
|
args: Schema.Array$<typeof Schema.Any>;
|
|
586
583
|
scheduledTime: typeof Schema.Number;
|
|
@@ -1028,7 +1025,7 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
|
|
|
1028
1025
|
sha256: convex_values0.VString<string, "required">;
|
|
1029
1026
|
size: convex_values0.VFloat64<number, "required">;
|
|
1030
1027
|
contentType: convex_values0.VString<string | undefined, "optional">;
|
|
1031
|
-
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<Tables<Schema
|
|
1028
|
+
}, "required", "sha256" | "size" | "contentType">, {}, {}, {}>, TableName>>)["convexDocument"], convex_server0.NamedSearchIndex<TableInfoWithName<DataModel<SystemTables | Tables<Schema>>, TableName>, IndexName>>) => convex_server0.SearchFilter) => OrderedQuery$1<TableInfo<WithName<Tables<Schema>, TableName>> | TableInfo<WithName<Table<"_scheduled_functions", Schema.Struct<{
|
|
1032
1029
|
name: typeof Schema.String;
|
|
1033
1030
|
args: Schema.Array$<typeof Schema.Any>;
|
|
1034
1031
|
scheduledTime: typeof Schema.Number;
|
|
@@ -1122,11 +1119,14 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
|
|
|
1122
1119
|
} | {
|
|
1123
1120
|
table: <const TableName extends TableNames<FromSchema<Schema>>>(tableName: TableName) => {
|
|
1124
1121
|
insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<Schema>, TableName>>) => Effect.Effect<convex_values0.GenericId<TableName>, DocumentEncodeError, never>;
|
|
1125
|
-
patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void,
|
|
1122
|
+
patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
|
|
1126
1123
|
replace: (id: convex_values0.GenericId<TableName>, value: convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
|
|
1127
1124
|
delete: (id: convex_values0.GenericId<TableName>) => Effect.Effect<void, never, never>;
|
|
1128
1125
|
};
|
|
1129
|
-
} |
|
|
1126
|
+
} | {
|
|
1127
|
+
runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
|
|
1128
|
+
runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
|
|
1129
|
+
} | StorageReader$1 | StorageWriter$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>), never, never>;
|
|
1130
1130
|
type MutationServices<Schema extends AnyWithProps> = DatabaseReader<Schema> | DatabaseWriter<Schema> | Auth$1 | Scheduler$1 | StorageReader$1 | StorageWriter$1 | QueryRunner | MutationRunner | MutationCtx<ToConvex<FromSchema<Schema>>>;
|
|
1131
1131
|
//#endregion
|
|
1132
1132
|
export { MutationServices, RegisteredConvexFunction_d_exports, make, mutationLayer };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,
|
|
1
|
+
{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,MAAA,mBAAA,kBAAA,CAAA,QAAA,EAAA,KAAA,EAAA,KAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,KAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,KAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,KAAA,IAAA,mBAAA,CAAA,UAAA,KAAA,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"}
|
|
@@ -72,10 +72,10 @@ declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs
|
|
|
72
72
|
handler: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
|
|
73
73
|
};
|
|
74
74
|
type ActionServices<DatabaseSchema_ extends AnyWithProps> = Scheduler$1 | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | QueryRunner | MutationRunner | ActionRunner | VectorSearch<FromSchema<DatabaseSchema_>> | ActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>;
|
|
75
|
-
declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) |
|
|
75
|
+
declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) | Auth$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | {
|
|
76
76
|
runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
|
|
77
77
|
runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
|
|
78
|
-
} |
|
|
78
|
+
} | StorageReader$1 | StorageWriter$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | StorageActionWriter$1 | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
|
|
79
79
|
vector: number[];
|
|
80
80
|
limit?: number;
|
|
81
81
|
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>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":"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
|
|
1
|
+
{"version":3,"file":"RegisteredFunction.d.ts","names":[],"sources":["../src/RegisteredFunction.ts"],"mappings":"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"}
|
|
@@ -26,7 +26,7 @@ declare const StorageActionWriter_base: effect_Context0.TagClass<StorageActionWr
|
|
|
26
26
|
store: (blob: Blob, options?: {
|
|
27
27
|
sha256?: string;
|
|
28
28
|
}) => Effect.Effect<GenericId<"_storage">, never, never>;
|
|
29
|
-
}) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E,
|
|
29
|
+
}) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | StorageActionWriter> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, StorageActionWriter> : Effect.Effect<X, never, StorageActionWriter>;
|
|
30
30
|
};
|
|
31
31
|
declare class StorageActionWriter extends StorageActionWriter_base {
|
|
32
32
|
static readonly layer: (storageActionWriter: StorageActionWriter$1) => Layer.Layer<StorageActionWriter, never, never>;
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@confect/server",
|
|
3
3
|
"description": "Backend bindings to the Convex platform",
|
|
4
|
-
"version": "9.0.0-next.
|
|
4
|
+
"version": "9.0.0-next.9",
|
|
5
5
|
"author": "RJ Dellecese",
|
|
6
6
|
"bugs": {
|
|
7
7
|
"url": "https://github.com/rjdellecese/confect/issues"
|
|
@@ -72,7 +72,7 @@
|
|
|
72
72
|
"@effect/platform-node": "^0.106.0",
|
|
73
73
|
"convex": "1.39.1",
|
|
74
74
|
"effect": "^3.21.2",
|
|
75
|
-
"@confect/core": "^9.0.0-next.
|
|
75
|
+
"@confect/core": "^9.0.0-next.9"
|
|
76
76
|
},
|
|
77
77
|
"repository": {
|
|
78
78
|
"type": "git",
|
package/src/DatabaseSchema.ts
CHANGED
|
@@ -14,7 +14,7 @@ export const isDatabaseSchema = (u: unknown): u is Any =>
|
|
|
14
14
|
/**
|
|
15
15
|
* A schema definition holding a record of bound `Table`s keyed by table
|
|
16
16
|
* name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;
|
|
17
|
-
* laziness
|
|
17
|
+
* laziness lives entirely on each `Table` (its `Fields`, `Doc`, and
|
|
18
18
|
* `tableDefinition` are lazy memoised getters), so this layer is a plain
|
|
19
19
|
* record indirection with no module-loading or async machinery.
|
|
20
20
|
*/
|