@niama/loops 0.2.0

package/src/component/_generated/api.ts

@@ -0,0 +1,253 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as actions from "../actions.js";
+import type * as aggregates from "../aggregates.js";
+import type * as helpers from "../helpers.js";
+import type * as http from "../http.js";
+import type * as mutations from "../mutations.js";
+import type * as queries from "../queries.js";
+import type * as tables_contacts from "../tables/contacts.js";
+import type * as tables_emailOperations from "../tables/emailOperations.js";
+import type * as validators from "../validators.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  actions: typeof actions;
+  aggregates: typeof aggregates;
+  helpers: typeof helpers;
+  http: typeof http;
+  mutations: typeof mutations;
+  queries: typeof queries;
+  "tables/contacts": typeof tables_contacts;
+  "tables/emailOperations": typeof tables_emailOperations;
+  validators: typeof validators;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {
+  contactAggregate: {
+    btree: {
+      aggregateBetween: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any },
+        { count: number; sum: number }
+      >;
+      aggregateBetweenBatch: FunctionReference<
+        "query",
+        "internal",
+        { queries: Array<{ k1?: any; k2?: any; namespace?: any }> },
+        Array<{ count: number; sum: number }>
+      >;
+      atNegativeOffset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any; offset: number },
+        { k: any; s: number; v: any }
+      >;
+      atOffset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; k2?: any; namespace?: any; offset: number },
+        { k: any; s: number; v: any }
+      >;
+      atOffsetBatch: FunctionReference<
+        "query",
+        "internal",
+        {
+          queries: Array<{
+            k1?: any;
+            k2?: any;
+            namespace?: any;
+            offset: number;
+          }>;
+        },
+        Array<{ k: any; s: number; v: any }>
+      >;
+      get: FunctionReference<
+        "query",
+        "internal",
+        { key: any; namespace?: any },
+        null | { k: any; s: number; v: any }
+      >;
+      offset: FunctionReference<
+        "query",
+        "internal",
+        { k1?: any; key: any; namespace?: any },
+        number
+      >;
+      offsetUntil: FunctionReference<
+        "query",
+        "internal",
+        { k2?: any; key: any; namespace?: any },
+        number
+      >;
+      paginate: FunctionReference<
+        "query",
+        "internal",
+        {
+          cursor?: string;
+          k1?: any;
+          k2?: any;
+          limit: number;
+          namespace?: any;
+          order: "asc" | "desc";
+        },
+        {
+          cursor: string;
+          isDone: boolean;
+          page: Array<{ k: any; s: number; v: any }>;
+        }
+      >;
+      paginateNamespaces: FunctionReference<
+        "query",
+        "internal",
+        { cursor?: string; limit: number },
+        { cursor: string; isDone: boolean; page: Array<any> }
+      >;
+      validate: FunctionReference<
+        "query",
+        "internal",
+        { namespace?: any },
+        any
+      >;
+    };
+    inspect: {
+      display: FunctionReference<"query", "internal", { namespace?: any }, any>;
+      dump: FunctionReference<"query", "internal", { namespace?: any }, string>;
+      inspectNode: FunctionReference<
+        "query",
+        "internal",
+        { namespace?: any; node?: string },
+        null
+      >;
+      listTreeNodes: FunctionReference<
+        "query",
+        "internal",
+        { take?: number },
+        Array<{
+          _creationTime: number;
+          _id: string;
+          aggregate?: { count: number; sum: number };
+          items: Array<{ k: any; s: number; v: any }>;
+          subtrees: Array<string>;
+        }>
+      >;
+      listTrees: FunctionReference<
+        "query",
+        "internal",
+        { take?: number },
+        Array<{
+          _creationTime: number;
+          _id: string;
+          maxNodeSize: number;
+          namespace?: any;
+          root: string;
+        }>
+      >;
+    };
+    public: {
+      clear: FunctionReference<
+        "mutation",
+        "internal",
+        { maxNodeSize?: number; namespace?: any; rootLazy?: boolean },
+        null
+      >;
+      delete_: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any },
+        null
+      >;
+      deleteIfExists: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any },
+        any
+      >;
+      init: FunctionReference<
+        "mutation",
+        "internal",
+        { maxNodeSize?: number; namespace?: any; rootLazy?: boolean },
+        null
+      >;
+      insert: FunctionReference<
+        "mutation",
+        "internal",
+        { key: any; namespace?: any; summand?: number; value: any },
+        null
+      >;
+      makeRootLazy: FunctionReference<
+        "mutation",
+        "internal",
+        { namespace?: any },
+        null
+      >;
+      replace: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          currentKey: any;
+          namespace?: any;
+          newKey: any;
+          newNamespace?: any;
+          summand?: number;
+          value: any;
+        },
+        null
+      >;
+      replaceOrInsert: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          currentKey: any;
+          namespace?: any;
+          newKey: any;
+          newNamespace?: any;
+          summand?: number;
+          value: any;
+        },
+        any
+      >;
+    };
+  };
+};

package/src/component/_generated/component.ts

@@ -0,0 +1,291 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type { FunctionReference } from "convex/server";
+
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> =
+  {
+    actions: {
+      addContact: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          contact: {
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            source?: string;
+            subscribed?: boolean;
+            userGroup?: string;
+            userId?: string;
+          };
+        },
+        { id?: string; success: boolean },
+        Name
+      >;
+      batchCreateContacts: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          contacts: Array<{
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            source?: string;
+            subscribed?: boolean;
+            userGroup?: string;
+            userId?: string;
+          }>;
+        },
+        {
+          created?: number;
+          failed?: number;
+          results?: Array<{ email: string; error?: string; success: boolean }>;
+          success: boolean;
+        },
+        Name
+      >;
+      deleteContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      findContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        {
+          contact?: {
+            createdAt?: string | null;
+            email?: string | null;
+            firstName?: string | null;
+            id?: string | null;
+            lastName?: string | null;
+            source?: string | null;
+            subscribed?: boolean | null;
+            userGroup?: string | null;
+            userId?: string | null;
+          };
+          success: boolean;
+        },
+        Name
+      >;
+      resubscribeContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      sendEvent: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          email: string;
+          eventName: string;
+          eventProperties?: Record<string, any>;
+        },
+        { success: boolean },
+        Name
+      >;
+      sendTransactional: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          transactionalId: string;
+        },
+        { messageId?: string; success: boolean },
+        Name
+      >;
+      triggerLoop: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          eventName?: string;
+          loopId: string;
+        },
+        { success: boolean; warning?: string },
+        Name
+      >;
+      unsubscribeContact: FunctionReference<
+        "action",
+        "internal",
+        { apiKey: string; email: string },
+        { success: boolean },
+        Name
+      >;
+      updateContact: FunctionReference<
+        "action",
+        "internal",
+        {
+          apiKey: string;
+          dataVariables?: Record<string, any>;
+          email: string;
+          firstName?: string;
+          lastName?: string;
+          source?: string;
+          subscribed?: boolean;
+          userGroup?: string;
+          userId?: string;
+        },
+        { success: boolean },
+        Name
+      >;
+    };
+    mutations: {
+      backfillContactAggregate: FunctionReference<
+        "mutation",
+        "internal",
+        { batchSize?: number; clear?: boolean; cursor?: string | null },
+        { cursor: string | null; isDone: boolean; processed: number },
+        Name
+      >;
+    };
+    queries: {
+      checkActorRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { actorId: string; maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          retryAfter?: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      checkGlobalRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      checkRecipientRateLimit: FunctionReference<
+        "query",
+        "internal",
+        { email: string; maxEmails: number; timeWindowMs: number },
+        {
+          allowed: boolean;
+          count: number;
+          limit: number;
+          retryAfter?: number;
+          timeWindowMs: number;
+        },
+        Name
+      >;
+      countContacts: FunctionReference<
+        "query",
+        "internal",
+        { source?: string; subscribed?: boolean; userGroup?: string },
+        number,
+        Name
+      >;
+      detectActorSpam: FunctionReference<
+        "query",
+        "internal",
+        { maxEmailsPerActor?: number; timeWindowMs?: number },
+        Array<{ actorId: string; count: number; timeWindowMs: number }>,
+        Name
+      >;
+      detectRapidFirePatterns: FunctionReference<
+        "query",
+        "internal",
+        { minEmailsInWindow?: number; timeWindowMs?: number },
+        Array<{
+          actorId?: string;
+          count: number;
+          email?: string;
+          firstTimestamp: number;
+          lastTimestamp: number;
+          timeWindowMs: number;
+        }>,
+        Name
+      >;
+      detectRecipientSpam: FunctionReference<
+        "query",
+        "internal",
+        { maxEmailsPerRecipient?: number; timeWindowMs?: number },
+        Array<{ count: number; email: string; timeWindowMs: number }>,
+        Name
+      >;
+      getEmailStats: FunctionReference<
+        "query",
+        "internal",
+        { timeWindowMs?: number },
+        {
+          failedOperations: number;
+          operationsByType: Record<string, number>;
+          successfulOperations: number;
+          totalOperations: number;
+          uniqueActors: number;
+          uniqueRecipients: number;
+        },
+        Name
+      >;
+      listContacts: FunctionReference<
+        "query",
+        "internal",
+        {
+          cursor?: string | null;
+          limit?: number;
+          source?: string;
+          subscribed?: boolean;
+          userGroup?: string;
+        },
+        {
+          contacts: Array<{
+            _id: string;
+            createdAt: number;
+            email: string;
+            firstName?: string;
+            lastName?: string;
+            loopsContactId?: string;
+            source?: string;
+            subscribed: boolean;
+            updatedAt: number;
+            userGroup?: string;
+            userId?: string;
+          }>;
+          continueCursor: string | null;
+          isDone: boolean;
+        },
+        Name
+      >;
+    };
+  };

package/src/component/_generated/dataModel.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;