@convex-dev/sharded-counter 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,246 @@
+# Convex Sharded Counter Component
+
+[![npm version](https://badge.fury.io/js/@convex-dev%2Fsharded-counter.svg)](https://badge.fury.io/js/@convex-dev%2Fsharded-counter)
+
+This component adds counters to Convex. It acts as a key-value store from
+string to number, with sharding to increase throughput when updating values.
+
+Since it's built on Convex, everything is automatically consistent, reactive,
+and cached.
+
+For example, if you want to display
+[one million checkboxes](https://en.wikipedia.org/wiki/One_Million_Checkboxes)
+[on your Convex site](https://www.youtube.com/watch?v=LRUWplYoejQ), you want to
+count the checkboxes in real-time while allowing lots of the boxes to change in
+parallel.
+
+More generally, whenever you have a counter that is changing frequently, you
+can use this component to keep track of it efficiently.
+
+```ts
+export const checkBox = mutation({
+  args: {i: v.number()},
+  handler: async (ctx, args) => {
+    const checkbox = await ctx.db.query("checkboxes")
+      .withIndex("i", q=>q.eq("i", args.i)).unique();
+    if (!checkbox.isChecked) {
+      await ctx.db.patch(checkbox._id, { isChecked: true });
+
+      // Here we increment the number of checkboxes.
+      await numCheckboxes.inc(ctx);
+    }
+  },
+});
+export const getCount = query({
+  args: {},
+  handler: async (ctx, _args) => {
+    return await numCheckboxes.count(ctx);
+  },
+});
+```
+
+## Installation
+
+First, install the component package:
+
+```ts
+npm install @convex-dev/sharded-counter
+```
+
+Then, create a `convex.config.ts` file in your app's `convex/` folder and install the
+component by calling `use`:
+
+```ts
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import shardedCounter from "@convex-dev/sharded-counter/convex.config";
+
+const app = defineApp();
+app.use(shardedCounter);
+
+export default app;
+```
+
+Finally, create a new `ShardedCounter` within your `convex/` folder, and point it to
+the installed component.
+
+```ts
+import { components } from "./_generated/api";
+import { ShardedCounter } from "@convex-dev/counter";
+
+const counter = new ShardedCounter(components.counter, {
+  ...options
+});
+```
+
+## Updating and reading counters
+
+Once you have a `ShardedCounter`, there are a few methods you can use to update
+the counter for a key in a mutation or action.
+
+```ts
+await counter.add(ctx, "checkboxes"); // increment
+await counter.add(ctx, "checkboxes", -5); // decrement by 5
+
+const numCheckboxes = counter.for("checkboxes");
+await numCheckboxes.inc(ctx); // increment
+await numCheckboxes.dec(ctx); // decrement
+await numCheckboxes.add(ctx, 5); // add 5
+await numCheckboxes.subtract(ctx, 5); // subtract 5
+```
+
+And you can read the counter's value in a query, mutation, or action.
+
+```ts
+await counter.count(ctx, "checkboxes");
+await numCheckboxes.count(ctx);
+```
+
+See more example usage in [example.ts](./example/convex/example.ts).
+
+## Sharding the counter
+
+When a single document is modified by two mutations at the same time, the
+mutations slow down to achieve
+[serializable results](https://docs.convex.dev/database/advanced/occ).
+
+To achieve high throughput, the ShardedCounter distributes counts across
+multiple documents, called "shards". Increments and decrements update a random
+shard, while queries of the total count read from all shards.
+
+1. More shards => greater throughput when incrementing or decrementing.
+2. Fewer shards => better latency when querying the count.
+
+You can set the number of shards when initializing the ShardedCounter, either
+setting it specially for each key:
+
+```ts
+const counter = new ShardedCounter(components.shardedCounter, {
+  shards: { checkboxes: 100 }, // 100 shards for the key "checkboxes"
+});
+```
+
+Or by setting a default that applies to all keys not specified in `shards`:
+
+```ts
+const counter = new ShardedCounter(components.shardedCounter, {
+  shards: { checkboxes: 100 },
+  defaultShards: 20,
+});
+```
+
+The default number of shards if none is specified is 16.
+
+Note your keys can be a subtype of string. e.g. if you want to store a count of
+friends for each user, and you don't care about throughput for a single user,
+you would declare ShardedCounter like so:
+
+```ts
+const friendCounts = new ShardedCounter<Record<Id<"users">, number>>(
+  components.shardedCounter,
+  { defaultShards: 1 },
+);
+```
+
+## Backfilling an existing count
+
+If you want to count items like documents in a table, you may already have
+documents before installing the ShardedCounter component, and these should be
+accounted for.
+
+The tricky part is making sure to merge active updates to counts with old
+values that you want to backfill.
+
+See example code at the bottom of
+[example/convex/example.ts](example/convex/example.ts).
+
+Walkthrough of steps:
+
+1. Create `backfillCursor` table in schema.ts
+2. Create a new document in this table, with fields
+`{ creationTime: 0, id: "", isDone: false }`
+3. Wherever you want to update a counter based on a document changing, wrap the
+update in a conditional, so it only gets updated if the backfill has processed
+that document. In the example, you would be changing `insertUserBeforeBackfill`
+to be implemented as `insertUserDuringBackfill`.
+4. Define backfill functions similar to `backfillUsers` and `backfillUsersBatch`
+5. Call `backfillUsersBatch` from the dashboard.
+6. Remove the conditional when updating counters. In the example, you would be
+changing `insertUserDuringBackfill` to be implemented as
+`insertUserAfterBackfill`.
+7. Delete the `backfillCursor` table.
+
+<!-- END: Include on https://convex.dev/components -->
+
+# 🧑‍🏫 What is Convex?
+
+[Convex](https://convex.dev) is a hosted backend platform with a
+built-in database that lets you write your
+[database schema](https://docs.convex.dev/database/schemas) and
+[server functions](https://docs.convex.dev/functions) in
+[TypeScript](https://docs.convex.dev/typescript). Server-side database
+[queries](https://docs.convex.dev/functions/query-functions) automatically
+[cache](https://docs.convex.dev/functions/query-functions#caching--reactivity) and
+[subscribe](https://docs.convex.dev/client/react#reactivity) to data, powering a
+[realtime `useQuery` hook](https://docs.convex.dev/client/react#fetching-data) in our
+[React client](https://docs.convex.dev/client/react). There are also clients for
+[Python](https://docs.convex.dev/client/python),
+[Rust](https://docs.convex.dev/client/rust),
+[ReactNative](https://docs.convex.dev/client/react-native), and
+[Node](https://docs.convex.dev/client/javascript), as well as a straightforward
+[HTTP API](https://docs.convex.dev/http-api/).
+
+The database supports
+[NoSQL-style documents](https://docs.convex.dev/database/document-storage) with
+[opt-in schema validation](https://docs.convex.dev/database/schemas),
+[relationships](https://docs.convex.dev/database/document-ids) and
+[custom indexes](https://docs.convex.dev/database/indexes/)
+(including on fields in nested objects).
+
+The
+[`query`](https://docs.convex.dev/functions/query-functions) and
+[`mutation`](https://docs.convex.dev/functions/mutation-functions) server functions have transactional,
+low latency access to the database and leverage our
+[`v8` runtime](https://docs.convex.dev/functions/runtimes) with
+[determinism guardrails](https://docs.convex.dev/functions/runtimes#using-randomness-and-time-in-queries-and-mutations)
+to provide the strongest ACID guarantees on the market:
+immediate consistency,
+serializable isolation, and
+automatic conflict resolution via
+[optimistic multi-version concurrency control](https://docs.convex.dev/database/advanced/occ) (OCC / MVCC).
+
+The [`action` server functions](https://docs.convex.dev/functions/actions) have
+access to external APIs and enable other side-effects and non-determinism in
+either our
+[optimized `v8` runtime](https://docs.convex.dev/functions/runtimes) or a more
+[flexible `node` runtime](https://docs.convex.dev/functions/runtimes#nodejs-runtime).
+
+Functions can run in the background via
+[scheduling](https://docs.convex.dev/scheduling/scheduled-functions) and
+[cron jobs](https://docs.convex.dev/scheduling/cron-jobs).
+
+Development is cloud-first, with
+[hot reloads for server function](https://docs.convex.dev/cli#run-the-convex-dev-server) editing via the
+[CLI](https://docs.convex.dev/cli),
+[preview deployments](https://docs.convex.dev/production/hosting/preview-deployments),
+[logging and exception reporting integrations](https://docs.convex.dev/production/integrations/),
+There is a
+[dashboard UI](https://docs.convex.dev/dashboard) to
+[browse and edit data](https://docs.convex.dev/dashboard/deployments/data),
+[edit environment variables](https://docs.convex.dev/production/environment-variables),
+[view logs](https://docs.convex.dev/dashboard/deployments/logs),
+[run server functions](https://docs.convex.dev/dashboard/deployments/functions), and more.
+
+There are built-in features for
+[reactive pagination](https://docs.convex.dev/database/pagination),
+[file storage](https://docs.convex.dev/file-storage),
+[reactive text search](https://docs.convex.dev/text-search),
+[vector search](https://docs.convex.dev/vector-search),
+[https endpoints](https://docs.convex.dev/functions/http-actions) (for webhooks),
+[snapshot import/export](https://docs.convex.dev/database/import-export/),
+[streaming import/export](https://docs.convex.dev/production/integrations/streaming-import-export), and
+[runtime validation](https://docs.convex.dev/database/schemas#validators) for
+[function arguments](https://docs.convex.dev/functions/args-validation) and
+[database data](https://docs.convex.dev/database/schemas#schema-validation).
+
+Everything scales automatically, and it’s [free to start](https://www.convex.dev/plans).

package/dist/commonjs/client/index.d.ts

@@ -0,0 +1,37 @@
+import { Expand, FunctionReference, GenericDataModel, GenericMutationCtx, GenericQueryCtx } from "convex/server";
+import { GenericId } from "convex/values";
+import { api } from "../component/_generated/api";
+export declare class ShardedCounter<Shards extends Record<string, number>> {
+    component: UseApi<typeof api>;
+    options?: {
+        shards?: Shards | undefined;
+        defaultShards?: number | undefined;
+    } | undefined;
+    constructor(component: UseApi<typeof api>, options?: {
+        shards?: Shards | undefined;
+        defaultShards?: number | undefined;
+    } | undefined);
+    add<Name extends string = keyof Shards & string>(ctx: RunMutationCtx, name: Name, count?: number): Promise<null>;
+    count<Name extends string = keyof Shards & string>(ctx: RunQueryCtx, name: Name): Promise<number>;
+    for<Name extends string = keyof Shards & string>(name: Name): {
+        add: (ctx: RunMutationCtx, count?: number) => Promise<null>;
+        subtract: (ctx: RunMutationCtx, count?: number) => Promise<null>;
+        inc: (ctx: RunMutationCtx) => Promise<null>;
+        dec: (ctx: RunMutationCtx) => Promise<null>;
+        count: (ctx: RunQueryCtx) => Promise<number>;
+    };
+}
+type RunQueryCtx = {
+    runQuery: GenericQueryCtx<GenericDataModel>["runQuery"];
+};
+type RunMutationCtx = {
+    runMutation: GenericMutationCtx<GenericDataModel>["runMutation"];
+};
+export type OpaqueIds<T> = T extends GenericId<infer _T> ? string : T extends (infer U)[] ? OpaqueIds<U>[] : T extends object ? {
+    [K in keyof T]: OpaqueIds<T[K]>;
+} : T;
+export type UseApi<API> = Expand<{
+    [mod in keyof API]: API[mod] extends FunctionReference<infer FType, "public", infer FArgs, infer FReturnType, infer FComponentPath> ? FunctionReference<FType, "internal", OpaqueIds<FArgs>, OpaqueIds<FReturnType>, FComponentPath> : UseApi<API[mod]>;
+}>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAC;AAElD,qBAAa,cAAc,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAEtD,SAAS,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC;IAC7B,OAAO,CAAC;;;;gBADR,SAAS,EAAE,MAAM,CAAC,OAAO,GAAG,CAAC,EAC7B,OAAO,CAAC;;;iBAA6C;IAExD,GAAG,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,MAAM,GAAG,MAAM,EACnD,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,IAAI,EACV,KAAK,GAAE,MAAU;IASb,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,MAAM,GAAG,MAAM,EACrD,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI;IAKZ,GAAG,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,IAAI;mBAEtC,cAAc,UAAS,MAAM;wBAExB,cAAc,UAAS,MAAM;mBAElC,cAAc;mBACd,cAAc;qBACZ,WAAW;;CAGnC;AAID,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC,UAAU,CAAC,CAAC;CACzD,CAAC;AACF,KAAK,cAAc,GAAG;IACpB,WAAW,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC,aAAa,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,SAAS,CAAC,CAAC,IACrB,CAAC,SAAS,SAAS,CAAC,MAAM,EAAE,CAAC,GACzB,MAAM,GACN,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACnB,SAAS,CAAC,CAAC,CAAC,EAAE,GACd,CAAC,SAAS,MAAM,GACd;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACnC,CAAC,CAAC;AAEZ,MAAM,MAAM,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC;KAC9B,GAAG,IAAI,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,SAAS,iBAAiB,CACpD,MAAM,KAAK,EACX,QAAQ,EACR,MAAM,KAAK,EACX,MAAM,WAAW,EACjB,MAAM,cAAc,CACrB,GACG,iBAAiB,CACf,KAAK,EACL,UAAU,EACV,SAAS,CAAC,KAAK,CAAC,EAChB,SAAS,CAAC,WAAW,CAAC,EACtB,cAAc,CACf,GACD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACrB,CAAC,CAAC"}

package/dist/commonjs/client/index.js

@@ -0,0 +1,30 @@
+export class ShardedCounter {
+    component;
+    options;
+    constructor(component, options) {
+        this.component = component;
+        this.options = options;
+    }
+    async add(ctx, name, count = 1) {
+        const shards = this.options?.shards?.[name] ?? this.options?.defaultShards;
+        return ctx.runMutation(this.component.public.add, {
+            name,
+            count,
+            shards,
+        });
+    }
+    async count(ctx, name) {
+        return ctx.runQuery(this.component.public.count, { name });
+    }
+    // Another way of exporting functionality
+    for(name) {
+        return {
+            add: async (ctx, count = 1) => this.add(ctx, name, count),
+            subtract: async (ctx, count = 1) => this.add(ctx, name, -count),
+            inc: async (ctx) => this.add(ctx, name, 1),
+            dec: async (ctx) => this.add(ctx, name, -1),
+            count: async (ctx) => this.count(ctx, name),
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/commonjs/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAUA,MAAM,OAAO,cAAc;IAEhB;IACA;IAFT,YACS,SAA6B,EAC7B,OAAqD;QADrD,cAAS,GAAT,SAAS,CAAoB;QAC7B,YAAO,GAAP,OAAO,CAA8C;IAC3D,CAAC;IACJ,KAAK,CAAC,GAAG,CACP,GAAmB,EACnB,IAAU,EACV,QAAgB,CAAC;QAEjB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC;QAC3E,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE;YAChD,IAAI;YACJ,KAAK;YACL,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IACD,KAAK,CAAC,KAAK,CACT,GAAgB,EAChB,IAAU;QAEV,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IACD,yCAAyC;IACzC,GAAG,CAA8C,IAAU;QACzD,OAAO;YACL,GAAG,EAAE,KAAK,EAAE,GAAmB,EAAE,QAAgB,CAAC,EAAE,EAAE,CACpD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC;YAC5B,QAAQ,EAAE,KAAK,EAAE,GAAmB,EAAE,QAAgB,CAAC,EAAE,EAAE,CACzD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC;YAC7B,GAAG,EAAE,KAAK,EAAE,GAAmB,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;YAC1D,GAAG,EAAE,KAAK,EAAE,GAAmB,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAC3D,KAAK,EAAE,KAAK,EAAE,GAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC;SACzD,CAAC;IACJ,CAAC;CACF"}

package/dist/commonjs/component/_generated/api.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: import("convex/server").AnyApi;
+export const internal: import("convex/server").AnyApi;
+export const components: {
+    [x: string]: import("../../../node_modules/convex/dist/esm-types/server/components").AnyComponentReference;
+};
+//# sourceMappingURL=api.d.ts.map

package/dist/commonjs/component/_generated/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/component/_generated/api.js"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,iDAA0B;AAC1B,sDAA+B;AAC/B;;EAA8C"}

package/dist/commonjs/component/_generated/api.js

@@ -0,0 +1,24 @@
+/* prettier-ignore-start */
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();
+/* prettier-ignore-end */
+//# sourceMappingURL=api.js.map

package/dist/commonjs/component/_generated/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../src/component/_generated/api.js"],"names":[],"mappings":"AAAA,2BAA2B;AAE3B,oBAAoB;AACpB;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,MAAM,CAAC;AAC1B,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC/B,MAAM,CAAC,MAAM,UAAU,GAAG,iBAAiB,EAAE,CAAC;AAE9C,yBAAyB"}

package/dist/commonjs/component/_generated/server.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: import("convex/server").QueryBuilder<any, "public">;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: import("convex/server").QueryBuilder<any, "internal">;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: import("convex/server").MutationBuilder<any, "public">;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: import("convex/server").MutationBuilder<any, "internal">;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: import("convex/server").ActionBuilder<any, "public">;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: import("convex/server").ActionBuilder<any, "internal">;
+/**
+ * Define a Convex HTTP action.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
+ * as its second.
+ * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
+ */
+export const httpAction: (func: (ctx: import("convex/server").GenericActionCtx<import("convex/server").GenericDataModel>, request: Request) => Promise<Response>) => import("convex/server").PublicHttpAction;
+//# sourceMappingURL=server.d.ts.map

package/dist/commonjs/component/_generated/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/component/_generated/server.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,wEAAkC;AAElC;;;;;;;GAOG;AACH,kFAAkD;AAElD;;;;;;;GAOG;AACH,8EAAwC;AAExC;;;;;;;GAOG;AACH,wFAAwD;AAExD;;;;;;;;;;GAUG;AACH,0EAAoC;AAEpC;;;;;GAKG;AACH,oFAAoD;AAEpD;;;;;;GAMG;AACH,8MAA4C"}