@bb-labs/convex-helpers 0.0.1 → 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,11 @@
+$ bldr
+
+[bldr] • project: ./tsconfig.json
+[bldr] → rootDir : ./src
+[bldr] → outDir  : ./dist
+[bldr] ▶ mode    : build
+
+⌫ cleaning output directory...
+✓ output directory cleaned
+▶ starting build...
+✓ [bldr] build completed successfully!

package/README.md

@@ -1,67 +1,43 @@
 ## Introduction
 
-A tiny utility that **deeply normalizes** JavaScript values by:
-
-- ✅ Recursively sorting **object keys**
-- ✅ Recursively sorting **arrays** using **SuperJSON** for deterministic comparison
-- ✅ Preserving non-plain objects (`Date`, `Map`, `Set`, `BigInt`, class instances, etc.)
-- ⚡ Perfect for generating cache keys, hashing structured data, or stabilizing query arguments
-
-The goal:
-**Identical structures always produce identical normalized output — even when key order or array order differs.**
-
----
+A lightweight utility library for [Convex](https://convex.dev) containing helpers.
 
 ## Installation
 
 ```bash
-npm install @bigbang-sdk/deep-sort
+npm install @bb-labs/convex-helpers
 # or
-yarn add @bigbang-sdk/deep-sort
+bun add @bb-labs/convex-helpers
 # or
-bun add @bigbang-sdk/deep-sort
+yarn add @bb-labs/convex-helpers
 ```
 
----
-
-## API
-
-### `deepSort(value: unknown): unknown`
-
-Returns a **fully normalized, deeply sorted copy** of any JSON-compatible data structure.
+## Helpers
 
-Behavior:
+### `createTable`
 
-- **Object keys** are sorted at every level
-- **Arrays** are deeply normalized, then **sorted** using SuperJSON’s structural encoding
-- Non-plain objects (Dates, Maps, Sets, etc.) are **preserved**, and naturally handled by SuperJSON
+A helper function that provides a declarative way to define Convex tables with schemas and indexes in a single, readable configuration object.
 
-```ts
-import { deepSort } from "@bigbang-sdk/deep-sort";
+```typescript
+import { createTable } from "@bb-labs/convex-helpers";
+import { v } from "convex/values";
 
-deepSort([3, 1, 2]);
-// → [1, 2, 3]
+const UserSchema = {
+  email: v.string(),
+  name: v.string(),
+  role: v.string(),
+  createdAt: v.number(),
+};
 
-deepSort([{ b: 2, a: 1 }, { a: 3 }]);
-// → [ { a: 1, b: 2 }, { a: 3 } ]
-
-deepSort([
-  { id: 2, tags: ["b", "a"] },
-  { id: 1, tags: ["c", "a"] },
-]);
-// → normalized deeply, sorted deterministically
+const usersTable = createTable({
+  schema: UserSchema,
+  indexes: [
+    { name: "by_email", fields: ["email"] },
+    { name: "by_role", fields: ["role", "createdAt"] },
+  ],
+});
 ```
 
----
-
-## Caveats
-
-- Sorting arrays by SuperJSON string is deterministic but may be expensive for very large/nested data.
-- Circular references are **not supported** (SuperJSON cannot serialize them).
-- This is intended for **cache key normalization**, **equality pre-normalization**, and **stable hashing** — not for mutating live data structuress.
-
----
-
 ## License
 
 MIT

package/dist/fns/create-table.d.ts

@@ -13,11 +13,11 @@ type CreateTableOptions<T extends SchemaDefinition> = {
  * Helper to define a Convex table with a declarative syntax.
  *
  * @example
- * export const otpsTable = createTable({
- *   schema: OtpSchema,
+ * const usersTable = createTable({
+ *   schema: UserSchema,
  *   indexes: [
- *     { name: "by_email_otp", fields: ["email", "otp"] },
- *     { name: "by_email", fields: ["email", "expiresAt"] },
+ *     { name: "by_email", fields: ["email"] },
+ *     { name: "by_role", fields: ["role", "createdAt"] },
  *   ],
  * });
  */

package/dist/fns/create-table.js

@@ -3,11 +3,11 @@ import { defineTable } from "convex/server";
  * Helper to define a Convex table with a declarative syntax.
  *
  * @example
- * export const otpsTable = createTable({
- *   schema: OtpSchema,
+ * const usersTable = createTable({
+ *   schema: UserSchema,
  *   indexes: [
- *     { name: "by_email_otp", fields: ["email", "otp"] },
- *     { name: "by_email", fields: ["email", "expiresAt"] },
+ *     { name: "by_email", fields: ["email"] },
+ *     { name: "by_role", fields: ["role", "createdAt"] },
  *   ],
  * });
  */

package/package.json

@@ -1,36 +1,27 @@
 {
   "name": "@bb-labs/convex-helpers",
-  "version": "0.0.1",
-  "author": "Beepbop",
+  "version": "0.0.3",
+  "npm": true,
   "repository": {
     "type": "git",
-    "url": "https://github.com/beepbop-labs/convex-helpers.git"
+    "url": "https://github.com/beepbop-labs/libraries.git"
   },
   "main": "dist/index.js",
-  "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "peerDependencies": {
-    "typescript": "^5"
-  },
-  "description": "A library for convex helpers",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "homepage": "https://github.com/beepbop-labs/convex-helpers",
-  "keywords": [
-    "convex-helpers",
-    "convex",
-    "helpers"
-  ],
-  "license": "MIT",
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "pack": "npm run build && npm pack --pack-destination ./archive/"
+    "build": "bldr",
+    "dev": "bldr -w",
+    "clean": "rm -rf node_modules bun.lock dist"
   },
   "dependencies": {
+    "@bb-labs/bldr": "^0.0.16",
+    "@bb-labs/tsconfigs": "^0.0.4",
     "convex": "^1.31.2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsc-alias": "^1.8.16"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
   }
 }

package/src/fns/create-table.ts

@@ -0,0 +1,39 @@
+import { defineTable, type TableDefinition, type GenericTableIndexes } from "convex/server";
+import type { GenericValidator, ObjectType, VObject } from "convex/values";
+
+type SchemaDefinition = Record<string, GenericValidator>;
+
+type IndexDefinition<T extends SchemaDefinition> = {
+  name: string;
+  fields: [keyof T & string, ...(keyof T & string)[]];
+};
+
+type CreateTableOptions<T extends SchemaDefinition> = {
+  schema: T;
+  indexes?: IndexDefinition<T>[];
+};
+
+/**
+ * Helper to define a Convex table with a declarative syntax.
+ *
+ * @example
+ * const usersTable = createTable({
+ *   schema: UserSchema,
+ *   indexes: [
+ *     { name: "by_email", fields: ["email"] },
+ *     { name: "by_role", fields: ["role", "createdAt"] },
+ *   ],
+ * });
+ */
+export function createTable<T extends SchemaDefinition>({
+  schema,
+  indexes = [],
+}: CreateTableOptions<T>): TableDefinition<VObject<ObjectType<T>, T>, GenericTableIndexes> {
+  let table: TableDefinition = defineTable(schema);
+
+  for (const index of indexes) {
+    table = table.index(index.name, index.fields);
+  }
+
+  return table as TableDefinition<VObject<ObjectType<T>, T>, GenericTableIndexes>;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./fns/create-table";

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@bb-labs/tsconfigs/lib.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}