@devwithbobby/loops 0.1.11 → 0.1.13
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/README.md +1 -24
- package/dist/client/index.d.ts +122 -52
- package/dist/client/index.d.ts.map +1 -1
- package/dist/client/index.js +15 -26
- package/dist/component/convex.config.d.ts +1 -1
- package/dist/component/convex.config.d.ts.map +1 -1
- package/dist/component/convex.config.js +0 -1
- package/dist/component/lib.d.ts +237 -29
- package/dist/component/lib.d.ts.map +1 -1
- package/dist/component/lib.js +47 -133
- package/dist/component/schema.d.ts +66 -1
- package/dist/component/schema.d.ts.map +1 -1
- package/dist/component/tables/contacts.d.ts +123 -1
- package/dist/component/tables/contacts.d.ts.map +1 -1
- package/dist/component/tables/emailOperations.d.ts +151 -1
- package/dist/component/tables/emailOperations.d.ts.map +1 -1
- package/dist/component/tables/emailOperations.js +1 -6
- package/dist/component/validators.d.ts +20 -3
- package/dist/component/validators.d.ts.map +1 -1
- package/dist/utils.d.ts +186 -3
- package/dist/utils.d.ts.map +1 -1
- package/package.json +101 -101
- package/src/client/index.ts +56 -57
- package/src/component/convex.config.ts +0 -1
- package/src/component/lib.ts +146 -219
- package/src/component/tables/contacts.ts +0 -1
- package/src/component/tables/emailOperations.ts +1 -7
- package/src/component/validators.ts +0 -1
|
@@ -1,2 +1,152 @@
|
|
|
1
|
-
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
export declare const EmailOperations: {
|
|
3
|
+
name: "emailOperations";
|
|
4
|
+
table: import("convex/server").TableDefinition<import("convex/values").VObject<{
|
|
5
|
+
actorId?: string | undefined;
|
|
6
|
+
transactionalId?: string | undefined;
|
|
7
|
+
campaignId?: string | undefined;
|
|
8
|
+
loopId?: string | undefined;
|
|
9
|
+
eventName?: string | undefined;
|
|
10
|
+
messageId?: string | undefined;
|
|
11
|
+
metadata?: Record<string, any> | undefined;
|
|
12
|
+
email: string;
|
|
13
|
+
success: boolean;
|
|
14
|
+
operationType: "transactional" | "event" | "campaign" | "loop";
|
|
15
|
+
timestamp: number;
|
|
16
|
+
}, import("zodvex").ConvexValidatorFromZodFieldsAuto<{
|
|
17
|
+
operationType: z.ZodEnum<{
|
|
18
|
+
transactional: "transactional";
|
|
19
|
+
event: "event";
|
|
20
|
+
campaign: "campaign";
|
|
21
|
+
loop: "loop";
|
|
22
|
+
}>;
|
|
23
|
+
email: z.ZodString;
|
|
24
|
+
actorId: z.ZodOptional<z.ZodString>;
|
|
25
|
+
transactionalId: z.ZodOptional<z.ZodString>;
|
|
26
|
+
campaignId: z.ZodOptional<z.ZodString>;
|
|
27
|
+
loopId: z.ZodOptional<z.ZodString>;
|
|
28
|
+
eventName: z.ZodOptional<z.ZodString>;
|
|
29
|
+
timestamp: z.ZodNumber;
|
|
30
|
+
success: z.ZodBoolean;
|
|
31
|
+
messageId: z.ZodOptional<z.ZodString>;
|
|
32
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
33
|
+
}>, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | `metadata.${string}`>, {}, {}, {}>;
|
|
34
|
+
doc: import("convex/values").VObject<{
|
|
35
|
+
actorId?: string | undefined;
|
|
36
|
+
transactionalId?: string | undefined;
|
|
37
|
+
campaignId?: string | undefined;
|
|
38
|
+
loopId?: string | undefined;
|
|
39
|
+
eventName?: string | undefined;
|
|
40
|
+
messageId?: string | undefined;
|
|
41
|
+
metadata?: Record<string, any> | undefined;
|
|
42
|
+
email: string;
|
|
43
|
+
success: boolean;
|
|
44
|
+
operationType: "transactional" | "event" | "campaign" | "loop";
|
|
45
|
+
timestamp: number;
|
|
46
|
+
_creationTime: number;
|
|
47
|
+
_id: import("convex/values").GenericId<"emailOperations">;
|
|
48
|
+
}, {
|
|
49
|
+
operationType: import("convex/values").VUnion<"transactional" | "event" | "campaign" | "loop", import("convex/values").VLiteral<"transactional" | "event" | "campaign" | "loop", "required">[], "required", never>;
|
|
50
|
+
email: import("convex/values").VString<string, "required">;
|
|
51
|
+
actorId: import("convex/values").VString<string | undefined, "optional">;
|
|
52
|
+
transactionalId: import("convex/values").VString<string | undefined, "optional">;
|
|
53
|
+
campaignId: import("convex/values").VString<string | undefined, "optional">;
|
|
54
|
+
loopId: import("convex/values").VString<string | undefined, "optional">;
|
|
55
|
+
eventName: import("convex/values").VString<string | undefined, "optional">;
|
|
56
|
+
timestamp: import("convex/values").VFloat64<number, "required">;
|
|
57
|
+
success: import("convex/values").VBoolean<boolean, "required">;
|
|
58
|
+
messageId: import("convex/values").VString<string | undefined, "optional">;
|
|
59
|
+
metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<"required", "required", string>, "optional", string>;
|
|
60
|
+
_id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
|
|
61
|
+
_creationTime: import("convex/values").VFloat64<number, "required">;
|
|
62
|
+
}, "required", "email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}` | "_id">;
|
|
63
|
+
withoutSystemFields: import("zodvex").ConvexValidatorFromZodFieldsAuto<{
|
|
64
|
+
operationType: z.ZodEnum<{
|
|
65
|
+
transactional: "transactional";
|
|
66
|
+
event: "event";
|
|
67
|
+
campaign: "campaign";
|
|
68
|
+
loop: "loop";
|
|
69
|
+
}>;
|
|
70
|
+
email: z.ZodString;
|
|
71
|
+
actorId: z.ZodOptional<z.ZodString>;
|
|
72
|
+
transactionalId: z.ZodOptional<z.ZodString>;
|
|
73
|
+
campaignId: z.ZodOptional<z.ZodString>;
|
|
74
|
+
loopId: z.ZodOptional<z.ZodString>;
|
|
75
|
+
eventName: z.ZodOptional<z.ZodString>;
|
|
76
|
+
timestamp: z.ZodNumber;
|
|
77
|
+
success: z.ZodBoolean;
|
|
78
|
+
messageId: z.ZodOptional<z.ZodString>;
|
|
79
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
80
|
+
}>;
|
|
81
|
+
withSystemFields: {
|
|
82
|
+
operationType: import("convex/values").VUnion<"transactional" | "event" | "campaign" | "loop", import("convex/values").VLiteral<"transactional" | "event" | "campaign" | "loop", "required">[], "required", never>;
|
|
83
|
+
email: import("convex/values").VString<string, "required">;
|
|
84
|
+
actorId: import("convex/values").VString<string | undefined, "optional">;
|
|
85
|
+
transactionalId: import("convex/values").VString<string | undefined, "optional">;
|
|
86
|
+
campaignId: import("convex/values").VString<string | undefined, "optional">;
|
|
87
|
+
loopId: import("convex/values").VString<string | undefined, "optional">;
|
|
88
|
+
eventName: import("convex/values").VString<string | undefined, "optional">;
|
|
89
|
+
timestamp: import("convex/values").VFloat64<number, "required">;
|
|
90
|
+
success: import("convex/values").VBoolean<boolean, "required">;
|
|
91
|
+
messageId: import("convex/values").VString<string | undefined, "optional">;
|
|
92
|
+
metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<"required", "required", string>, "optional", string>;
|
|
93
|
+
_id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
|
|
94
|
+
_creationTime: import("convex/values").VFloat64<number, "required">;
|
|
95
|
+
};
|
|
96
|
+
systemFields: {
|
|
97
|
+
_id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
|
|
98
|
+
_creationTime: import("convex/values").VFloat64<number, "required">;
|
|
99
|
+
};
|
|
100
|
+
_id: import("convex/values").VId<import("convex/values").GenericId<"emailOperations">, "required">;
|
|
101
|
+
} & {
|
|
102
|
+
shape: {
|
|
103
|
+
operationType: z.ZodEnum<{
|
|
104
|
+
transactional: "transactional";
|
|
105
|
+
event: "event";
|
|
106
|
+
campaign: "campaign";
|
|
107
|
+
loop: "loop";
|
|
108
|
+
}>;
|
|
109
|
+
email: z.ZodString;
|
|
110
|
+
actorId: z.ZodOptional<z.ZodString>;
|
|
111
|
+
transactionalId: z.ZodOptional<z.ZodString>;
|
|
112
|
+
campaignId: z.ZodOptional<z.ZodString>;
|
|
113
|
+
loopId: z.ZodOptional<z.ZodString>;
|
|
114
|
+
eventName: z.ZodOptional<z.ZodString>;
|
|
115
|
+
timestamp: z.ZodNumber;
|
|
116
|
+
success: z.ZodBoolean;
|
|
117
|
+
messageId: z.ZodOptional<z.ZodString>;
|
|
118
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
119
|
+
};
|
|
120
|
+
zDoc: z.ZodObject<{
|
|
121
|
+
operationType: z.ZodEnum<{
|
|
122
|
+
transactional: "transactional";
|
|
123
|
+
event: "event";
|
|
124
|
+
campaign: "campaign";
|
|
125
|
+
loop: "loop";
|
|
126
|
+
}>;
|
|
127
|
+
email: z.ZodString;
|
|
128
|
+
actorId: z.ZodOptional<z.ZodString>;
|
|
129
|
+
transactionalId: z.ZodOptional<z.ZodString>;
|
|
130
|
+
campaignId: z.ZodOptional<z.ZodString>;
|
|
131
|
+
loopId: z.ZodOptional<z.ZodString>;
|
|
132
|
+
eventName: z.ZodOptional<z.ZodString>;
|
|
133
|
+
timestamp: z.ZodNumber;
|
|
134
|
+
success: z.ZodBoolean;
|
|
135
|
+
messageId: z.ZodOptional<z.ZodString>;
|
|
136
|
+
metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
137
|
+
} & {
|
|
138
|
+
_id: z.ZodType<import("convex/values").GenericId<"emailOperations">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"emailOperations">, unknown>> & {
|
|
139
|
+
_tableName: "emailOperations";
|
|
140
|
+
};
|
|
141
|
+
_creationTime: z.ZodNumber;
|
|
142
|
+
}, z.core.$strip>;
|
|
143
|
+
docArray: z.ZodArray<z.ZodObject<Readonly<{
|
|
144
|
+
[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
|
|
145
|
+
}> & {
|
|
146
|
+
_id: z.ZodType<import("convex/values").GenericId<"emailOperations">, unknown, z.core.$ZodTypeInternals<import("convex/values").GenericId<"emailOperations">, unknown>> & {
|
|
147
|
+
_tableName: "emailOperations";
|
|
148
|
+
};
|
|
149
|
+
_creationTime: z.ZodNumber;
|
|
150
|
+
}, z.core.$strip>>;
|
|
151
|
+
};
|
|
2
152
|
//# sourceMappingURL=emailOperations.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"emailOperations.d.ts","sourceRoot":"","sources":["../../../src/component/tables/emailOperations.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"emailOperations.d.ts","sourceRoot":"","sources":["../../../src/component/tables/emailOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAY1B,CAAC"}
|
|
@@ -1,12 +1,7 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
2
|
import { zodTable } from "zodvex";
|
|
3
3
|
export const EmailOperations = zodTable("emailOperations", {
|
|
4
|
-
operationType: z.enum([
|
|
5
|
-
"transactional",
|
|
6
|
-
"event",
|
|
7
|
-
"campaign",
|
|
8
|
-
"loop",
|
|
9
|
-
]),
|
|
4
|
+
operationType: z.enum(["transactional", "event", "campaign", "loop"]),
|
|
10
5
|
email: z.string().email(),
|
|
11
6
|
actorId: z.string().optional(),
|
|
12
7
|
transactionalId: z.string().optional(),
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
1
2
|
/**
|
|
2
3
|
* Validators for Loops API requests and component operations
|
|
3
4
|
*/
|
|
@@ -5,14 +6,30 @@
|
|
|
5
6
|
* Validator for contact data
|
|
6
7
|
* Used for creating and updating contacts
|
|
7
8
|
*/
|
|
8
|
-
export declare const contactValidator:
|
|
9
|
+
export declare const contactValidator: z.ZodObject<{
|
|
10
|
+
email: z.ZodString;
|
|
11
|
+
firstName: z.ZodOptional<z.ZodString>;
|
|
12
|
+
lastName: z.ZodOptional<z.ZodString>;
|
|
13
|
+
userId: z.ZodOptional<z.ZodString>;
|
|
14
|
+
source: z.ZodOptional<z.ZodString>;
|
|
15
|
+
subscribed: z.ZodOptional<z.ZodBoolean>;
|
|
16
|
+
userGroup: z.ZodOptional<z.ZodString>;
|
|
17
|
+
}, z.core.$strip>;
|
|
9
18
|
/**
|
|
10
19
|
* Validator for transactional email requests
|
|
11
20
|
*/
|
|
12
|
-
export declare const transactionalEmailValidator:
|
|
21
|
+
export declare const transactionalEmailValidator: z.ZodObject<{
|
|
22
|
+
transactionalId: z.ZodOptional<z.ZodString>;
|
|
23
|
+
email: z.ZodString;
|
|
24
|
+
dataVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
25
|
+
}, z.core.$strip>;
|
|
13
26
|
/**
|
|
14
27
|
* Validator for event requests
|
|
15
28
|
* Used for sending events that trigger email workflows
|
|
16
29
|
*/
|
|
17
|
-
export declare const eventValidator:
|
|
30
|
+
export declare const eventValidator: z.ZodObject<{
|
|
31
|
+
email: z.ZodString;
|
|
32
|
+
eventName: z.ZodString;
|
|
33
|
+
eventProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
|
|
34
|
+
}, z.core.$strip>;
|
|
18
35
|
//# sourceMappingURL=validators.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/component/validators.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/component/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;iBAQ3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC"}
|
package/dist/utils.d.ts
CHANGED
|
@@ -1,4 +1,187 @@
|
|
|
1
|
-
export declare const zq:
|
|
2
|
-
|
|
3
|
-
|
|
1
|
+
export declare const zq: <A extends import("zod").ZodType | Record<string, import("zod").ZodType>, R extends import("zod").ZodType | undefined = undefined, Visibility extends import("convex/server").FunctionVisibility = "public">(config: {
|
|
2
|
+
args?: A | undefined;
|
|
3
|
+
handler: (ctx: import("convex/server").GenericQueryCtx<{
|
|
4
|
+
contacts: {
|
|
5
|
+
document: {
|
|
6
|
+
_id: import("convex/values").GenericId<"contacts">;
|
|
7
|
+
_creationTime: number;
|
|
8
|
+
firstName?: string | undefined;
|
|
9
|
+
lastName?: string | undefined;
|
|
10
|
+
userId?: string | undefined;
|
|
11
|
+
source?: string | undefined;
|
|
12
|
+
subscribed?: boolean | undefined;
|
|
13
|
+
userGroup?: string | undefined;
|
|
14
|
+
loopsContactId?: string | undefined;
|
|
15
|
+
email: string;
|
|
16
|
+
createdAt: number;
|
|
17
|
+
updatedAt: number;
|
|
18
|
+
};
|
|
19
|
+
fieldPaths: ("email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt" | "_creationTime") | "_id";
|
|
20
|
+
indexes: {
|
|
21
|
+
email: ["email", "_creationTime"];
|
|
22
|
+
userId: ["userId", "_creationTime"];
|
|
23
|
+
userGroup: ["userGroup", "_creationTime"];
|
|
24
|
+
source: ["source", "_creationTime"];
|
|
25
|
+
subscribed: ["subscribed", "_creationTime"];
|
|
26
|
+
by_id: ["_id"];
|
|
27
|
+
by_creation_time: ["_creationTime"];
|
|
28
|
+
};
|
|
29
|
+
searchIndexes: {};
|
|
30
|
+
vectorIndexes: {};
|
|
31
|
+
};
|
|
32
|
+
emailOperations: {
|
|
33
|
+
document: {
|
|
34
|
+
_id: import("convex/values").GenericId<"emailOperations">;
|
|
35
|
+
_creationTime: number;
|
|
36
|
+
actorId?: string | undefined;
|
|
37
|
+
transactionalId?: string | undefined;
|
|
38
|
+
campaignId?: string | undefined;
|
|
39
|
+
loopId?: string | undefined;
|
|
40
|
+
eventName?: string | undefined;
|
|
41
|
+
messageId?: string | undefined;
|
|
42
|
+
metadata?: Record<string, any> | undefined;
|
|
43
|
+
email: string;
|
|
44
|
+
success: boolean;
|
|
45
|
+
operationType: "transactional" | "event" | "campaign" | "loop";
|
|
46
|
+
timestamp: number;
|
|
47
|
+
};
|
|
48
|
+
fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
|
|
49
|
+
indexes: {
|
|
50
|
+
email: ["email", "timestamp", "_creationTime"];
|
|
51
|
+
actorId: ["actorId", "timestamp", "_creationTime"];
|
|
52
|
+
operationType: ["operationType", "timestamp", "_creationTime"];
|
|
53
|
+
timestamp: ["timestamp", "_creationTime"];
|
|
54
|
+
by_id: ["_id"];
|
|
55
|
+
by_creation_time: ["_creationTime"];
|
|
56
|
+
};
|
|
57
|
+
searchIndexes: {};
|
|
58
|
+
vectorIndexes: {};
|
|
59
|
+
};
|
|
60
|
+
}>, args: import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => import("zodvex").InferHandlerReturns<R> | Promise<import("zodvex").InferHandlerReturns<R>>;
|
|
61
|
+
returns?: R | undefined;
|
|
62
|
+
}) => import("convex/server").RegisteredQuery<Visibility, import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<import("zodvex").InferReturns<R>>>;
|
|
63
|
+
export declare const zm: <A extends import("zod").ZodType | Record<string, import("zod").ZodType>, R extends import("zod").ZodType | undefined = undefined, Visibility extends import("convex/server").FunctionVisibility = "public">(config: {
|
|
64
|
+
args?: A | undefined;
|
|
65
|
+
handler: (ctx: import("convex/server").GenericMutationCtx<{
|
|
66
|
+
contacts: {
|
|
67
|
+
document: {
|
|
68
|
+
_id: import("convex/values").GenericId<"contacts">;
|
|
69
|
+
_creationTime: number;
|
|
70
|
+
firstName?: string | undefined;
|
|
71
|
+
lastName?: string | undefined;
|
|
72
|
+
userId?: string | undefined;
|
|
73
|
+
source?: string | undefined;
|
|
74
|
+
subscribed?: boolean | undefined;
|
|
75
|
+
userGroup?: string | undefined;
|
|
76
|
+
loopsContactId?: string | undefined;
|
|
77
|
+
email: string;
|
|
78
|
+
createdAt: number;
|
|
79
|
+
updatedAt: number;
|
|
80
|
+
};
|
|
81
|
+
fieldPaths: ("email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt" | "_creationTime") | "_id";
|
|
82
|
+
indexes: {
|
|
83
|
+
email: ["email", "_creationTime"];
|
|
84
|
+
userId: ["userId", "_creationTime"];
|
|
85
|
+
userGroup: ["userGroup", "_creationTime"];
|
|
86
|
+
source: ["source", "_creationTime"];
|
|
87
|
+
subscribed: ["subscribed", "_creationTime"];
|
|
88
|
+
by_id: ["_id"];
|
|
89
|
+
by_creation_time: ["_creationTime"];
|
|
90
|
+
};
|
|
91
|
+
searchIndexes: {};
|
|
92
|
+
vectorIndexes: {};
|
|
93
|
+
};
|
|
94
|
+
emailOperations: {
|
|
95
|
+
document: {
|
|
96
|
+
_id: import("convex/values").GenericId<"emailOperations">;
|
|
97
|
+
_creationTime: number;
|
|
98
|
+
actorId?: string | undefined;
|
|
99
|
+
transactionalId?: string | undefined;
|
|
100
|
+
campaignId?: string | undefined;
|
|
101
|
+
loopId?: string | undefined;
|
|
102
|
+
eventName?: string | undefined;
|
|
103
|
+
messageId?: string | undefined;
|
|
104
|
+
metadata?: Record<string, any> | undefined;
|
|
105
|
+
email: string;
|
|
106
|
+
success: boolean;
|
|
107
|
+
operationType: "transactional" | "event" | "campaign" | "loop";
|
|
108
|
+
timestamp: number;
|
|
109
|
+
};
|
|
110
|
+
fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
|
|
111
|
+
indexes: {
|
|
112
|
+
email: ["email", "timestamp", "_creationTime"];
|
|
113
|
+
actorId: ["actorId", "timestamp", "_creationTime"];
|
|
114
|
+
operationType: ["operationType", "timestamp", "_creationTime"];
|
|
115
|
+
timestamp: ["timestamp", "_creationTime"];
|
|
116
|
+
by_id: ["_id"];
|
|
117
|
+
by_creation_time: ["_creationTime"];
|
|
118
|
+
};
|
|
119
|
+
searchIndexes: {};
|
|
120
|
+
vectorIndexes: {};
|
|
121
|
+
};
|
|
122
|
+
}>, args: import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => import("zodvex").InferHandlerReturns<R> | Promise<import("zodvex").InferHandlerReturns<R>>;
|
|
123
|
+
returns?: R | undefined;
|
|
124
|
+
}) => import("convex/server").RegisteredMutation<Visibility, import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<import("zodvex").InferReturns<R>>>;
|
|
125
|
+
export declare const za: <A extends import("zod").ZodType | Record<string, import("zod").ZodType>, R extends import("zod").ZodType | undefined = undefined, Visibility extends import("convex/server").FunctionVisibility = "public">(config: {
|
|
126
|
+
args?: A | undefined;
|
|
127
|
+
handler: (ctx: import("convex/server").GenericActionCtx<{
|
|
128
|
+
contacts: {
|
|
129
|
+
document: {
|
|
130
|
+
_id: import("convex/values").GenericId<"contacts">;
|
|
131
|
+
_creationTime: number;
|
|
132
|
+
firstName?: string | undefined;
|
|
133
|
+
lastName?: string | undefined;
|
|
134
|
+
userId?: string | undefined;
|
|
135
|
+
source?: string | undefined;
|
|
136
|
+
subscribed?: boolean | undefined;
|
|
137
|
+
userGroup?: string | undefined;
|
|
138
|
+
loopsContactId?: string | undefined;
|
|
139
|
+
email: string;
|
|
140
|
+
createdAt: number;
|
|
141
|
+
updatedAt: number;
|
|
142
|
+
};
|
|
143
|
+
fieldPaths: ("email" | "firstName" | "lastName" | "userId" | "source" | "subscribed" | "userGroup" | "loopsContactId" | "createdAt" | "updatedAt" | "_creationTime") | "_id";
|
|
144
|
+
indexes: {
|
|
145
|
+
email: ["email", "_creationTime"];
|
|
146
|
+
userId: ["userId", "_creationTime"];
|
|
147
|
+
userGroup: ["userGroup", "_creationTime"];
|
|
148
|
+
source: ["source", "_creationTime"];
|
|
149
|
+
subscribed: ["subscribed", "_creationTime"];
|
|
150
|
+
by_id: ["_id"];
|
|
151
|
+
by_creation_time: ["_creationTime"];
|
|
152
|
+
};
|
|
153
|
+
searchIndexes: {};
|
|
154
|
+
vectorIndexes: {};
|
|
155
|
+
};
|
|
156
|
+
emailOperations: {
|
|
157
|
+
document: {
|
|
158
|
+
_id: import("convex/values").GenericId<"emailOperations">;
|
|
159
|
+
_creationTime: number;
|
|
160
|
+
actorId?: string | undefined;
|
|
161
|
+
transactionalId?: string | undefined;
|
|
162
|
+
campaignId?: string | undefined;
|
|
163
|
+
loopId?: string | undefined;
|
|
164
|
+
eventName?: string | undefined;
|
|
165
|
+
messageId?: string | undefined;
|
|
166
|
+
metadata?: Record<string, any> | undefined;
|
|
167
|
+
email: string;
|
|
168
|
+
success: boolean;
|
|
169
|
+
operationType: "transactional" | "event" | "campaign" | "loop";
|
|
170
|
+
timestamp: number;
|
|
171
|
+
};
|
|
172
|
+
fieldPaths: ("email" | "success" | "operationType" | "actorId" | "transactionalId" | "campaignId" | "loopId" | "eventName" | "timestamp" | "messageId" | "metadata" | "_creationTime" | `metadata.${string}`) | "_id";
|
|
173
|
+
indexes: {
|
|
174
|
+
email: ["email", "timestamp", "_creationTime"];
|
|
175
|
+
actorId: ["actorId", "timestamp", "_creationTime"];
|
|
176
|
+
operationType: ["operationType", "timestamp", "_creationTime"];
|
|
177
|
+
timestamp: ["timestamp", "_creationTime"];
|
|
178
|
+
by_id: ["_id"];
|
|
179
|
+
by_creation_time: ["_creationTime"];
|
|
180
|
+
};
|
|
181
|
+
searchIndexes: {};
|
|
182
|
+
vectorIndexes: {};
|
|
183
|
+
};
|
|
184
|
+
}>, args: import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>) => import("zodvex").InferHandlerReturns<R> | Promise<import("zodvex").InferHandlerReturns<R>>;
|
|
185
|
+
returns?: R | undefined;
|
|
186
|
+
}) => import("convex/server").RegisteredAction<Visibility, import("zodvex").ZodToConvexArgs<A extends undefined ? Record<string, never> : A>, Promise<import("zodvex").InferReturns<R>>>;
|
|
4
187
|
//# sourceMappingURL=utils.d.ts.map
|
package/dist/utils.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,EAAE,
|
|
1
|
+
{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uLAAuB,CAAC;AACvC,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0LAA6B,CAAC;AAC7C,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wLAAyB,CAAC"}
|
package/package.json
CHANGED
|
@@ -1,103 +1,103 @@
|
|
|
1
1
|
{
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
2
|
+
"name": "@devwithbobby/loops",
|
|
3
|
+
"version": "0.1.13",
|
|
4
|
+
"description": "Convex component for integrating with Loops.so email marketing platform",
|
|
5
|
+
"license": "Apache-2.0",
|
|
6
|
+
"type": "module",
|
|
7
|
+
"keywords": [
|
|
8
|
+
"convex",
|
|
9
|
+
"component",
|
|
10
|
+
"template",
|
|
11
|
+
"boilerplate",
|
|
12
|
+
"bun",
|
|
13
|
+
"biome",
|
|
14
|
+
"typescript"
|
|
15
|
+
],
|
|
16
|
+
"repository": {
|
|
17
|
+
"type": "git",
|
|
18
|
+
"url": "git+https://github.com/robertalv/loops.git"
|
|
19
|
+
},
|
|
20
|
+
"bugs": {
|
|
21
|
+
"url": "https://github.com/robertalv/loops/issues"
|
|
22
|
+
},
|
|
23
|
+
"homepage": "https://github.com/robertalv/loops#readme",
|
|
24
|
+
"files": [
|
|
25
|
+
"dist",
|
|
26
|
+
"src",
|
|
27
|
+
"README.md",
|
|
28
|
+
"LICENSE"
|
|
29
|
+
],
|
|
30
|
+
"exports": {
|
|
31
|
+
"./package.json": "./package.json",
|
|
32
|
+
".": {
|
|
33
|
+
"@convex-dev/component-source": "./src/client/index.ts",
|
|
34
|
+
"types": "./dist/client/index.d.ts",
|
|
35
|
+
"default": "./dist/client/index.js"
|
|
36
|
+
},
|
|
37
|
+
"./convex.config": {
|
|
38
|
+
"@convex-dev/component-source": "./src/component/convex.config.ts",
|
|
39
|
+
"types": "./dist/component/convex.config.d.ts",
|
|
40
|
+
"default": "./src/component/convex.config.ts"
|
|
41
|
+
}
|
|
42
|
+
},
|
|
43
|
+
"scripts": {
|
|
44
|
+
"dev": "run-p -r 'dev:backend' 'dev:frontend' 'build:watch'",
|
|
45
|
+
"dev:backend": "convex dev --live-component-sources --typecheck-components",
|
|
46
|
+
"dev:frontend": "bun --hot example/src/index.tsx",
|
|
47
|
+
"build": "tsc --project tsconfig.build.json",
|
|
48
|
+
"build:watch": "chokidar 'tsconfig*.json' 'src/**/*.ts' -i '**/*.test.*' -i '**/test-setup.ts' -c 'bun run build' --initial",
|
|
49
|
+
"clean": "rm -rf dist node_modules",
|
|
50
|
+
"test": "bun test",
|
|
51
|
+
"test:watch": "bun test --watch",
|
|
52
|
+
"test:coverage": "bun test --coverage",
|
|
53
|
+
"test:bail": "bun test --bail",
|
|
54
|
+
"lint": "biome lint .",
|
|
55
|
+
"lint:fix": "biome lint --write .",
|
|
56
|
+
"format": "biome format --write .",
|
|
57
|
+
"check": "biome check .",
|
|
58
|
+
"check:fix": "biome check --write .",
|
|
59
|
+
"typecheck": "tsc --noEmit",
|
|
60
|
+
"attw": "attw $(npm pack -s) --exclude-entrypoints ./convex.config --profile esm-only",
|
|
61
|
+
"prepare": "npm run build || true",
|
|
62
|
+
"changeset": "changeset",
|
|
63
|
+
"ci:version": "changeset version && bun update",
|
|
64
|
+
"ci:publish": "changeset publish",
|
|
65
|
+
"preversion": "bun run clean && bun install && run-p test lint typecheck attw",
|
|
66
|
+
"version": "pbcopy <<<$npm_package_version; vim CHANGELOG.md && biome format --write CHANGELOG.md && git add CHANGELOG.md",
|
|
67
|
+
"postversion": "git push --follow-tags",
|
|
68
|
+
"alpha": "bun run preversion && npm version prerelease --preid alpha && npm publish --tag alpha",
|
|
69
|
+
"release": "bun run preversion && npm version patch && npm publish"
|
|
70
|
+
},
|
|
71
|
+
"dependencies": {
|
|
72
|
+
"zod": "^4.1.12",
|
|
73
|
+
"zodvex": "^0.2.3"
|
|
74
|
+
},
|
|
75
|
+
"peerDependencies": {
|
|
76
|
+
"convex": "^1.0.0",
|
|
77
|
+
"react": "^18.0.0 || ^19.0.0",
|
|
78
|
+
"typescript": "^5.9.3"
|
|
79
|
+
},
|
|
80
|
+
"devDependencies": {
|
|
81
|
+
"@arethetypeswrong/cli": "^0.18.2",
|
|
82
|
+
"@biomejs/biome": "2.3.0",
|
|
83
|
+
"@changesets/changelog-github": "^0.5.1",
|
|
84
|
+
"@changesets/cli": "^2.29.7",
|
|
85
|
+
"@commitlint/cli": "^20.1.0",
|
|
86
|
+
"@commitlint/types": "^20.0.0",
|
|
87
|
+
"@types/bun": "^1.3.1",
|
|
88
|
+
"@types/react": "^19.2.2",
|
|
89
|
+
"@types/react-dom": "^19.2.2",
|
|
90
|
+
"bun-plugin-tailwind": "^0.1.2",
|
|
91
|
+
"chokidar-cli": "^3.0.0",
|
|
92
|
+
"commitlint-config-gitmoji": "^2.3.1",
|
|
93
|
+
"convex": "^1.28.0",
|
|
94
|
+
"convex-helpers": "^0.1.104",
|
|
95
|
+
"convex-test": "^0.0.38",
|
|
96
|
+
"lefthook": "^2.0.0",
|
|
97
|
+
"npm-run-all": "^4.1.5",
|
|
98
|
+
"pkg-pr-new": "^0.0.60",
|
|
99
|
+
"react": "^19.2.0",
|
|
100
|
+
"react-dom": "^19.2.0",
|
|
101
|
+
"tailwindcss": "^4.1.16"
|
|
102
|
+
}
|
|
103
103
|
}
|