@nordsym/apiclaw 1.0.0

package/backend/convex/_generated/server.js

@@ -0,0 +1,93 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+
+/**
+ * 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 = queryGeneric;
+
+/**
+ * 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 = internalQueryGeneric;
+
+/**
+ * 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 = mutationGeneric;
+
+/**
+ * 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 = internalMutationGeneric;
+
+/**
+ * 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 = actionGeneric;
+
+/**
+ * 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 = internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;

package/backend/convex/apiKeys.ts

@@ -0,0 +1,75 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Add a new API key
+export const add = mutation({
+  args: {
+    userEmail: v.string(),
+    apiId: v.string(),
+    apiName: v.string(),
+    keyName: v.string(),
+    keyValue: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const id = await ctx.db.insert("apiKeys", {
+      userEmail: args.userEmail,
+      apiId: args.apiId,
+      apiName: args.apiName,
+      keyName: args.keyName,
+      keyValue: args.keyValue,
+      createdAt: Date.now(),
+    });
+    return id;
+  },
+});
+
+// Get all keys for a user
+export const listByEmail = query({
+  args: { userEmail: v.string() },
+  handler: async (ctx, args) => {
+    const keys = await ctx.db
+      .query("apiKeys")
+      .withIndex("by_email", (q) => q.eq("userEmail", args.userEmail))
+      .collect();
+    // Return without exposing full key values
+    return keys.map((k) => ({
+      ...k,
+      keyValue: k.keyValue.slice(0, 4) + "..." + k.keyValue.slice(-4),
+      _fullKey: undefined, // never expose
+    }));
+  },
+});
+
+// Get a specific key (for agent use - requires auth in prod)
+export const get = query({
+  args: { 
+    userEmail: v.string(),
+    apiId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const keys = await ctx.db
+      .query("apiKeys")
+      .withIndex("by_email_and_api", (q) => 
+        q.eq("userEmail", args.userEmail).eq("apiId", args.apiId)
+      )
+      .collect();
+    return keys;
+  },
+});
+
+// Delete a key
+export const remove = mutation({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});
+
+// Update last used timestamp
+export const markUsed = mutation({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, { lastUsed: Date.now() });
+  },
+});

package/backend/convex/purchases.ts

@@ -0,0 +1,74 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// Create new API purchase
+export const create = mutation({
+  args: {
+    userId: v.id("users"),
+    apiId: v.string(),
+    credentials: v.any(),
+    expiresAt: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const purchaseId = await ctx.db.insert("purchases", {
+      userId: args.userId,
+      apiId: args.apiId,
+      credentials: args.credentials,
+      status: "active",
+      purchasedAt: Date.now(),
+      expiresAt: args.expiresAt,
+    });
+
+    return purchaseId;
+  },
+});
+
+// List user's active purchases
+export const listByUser = query({
+  args: {
+    userId: v.id("users"),
+  },
+  handler: async (ctx, args) => {
+    const purchases = await ctx.db
+      .query("purchases")
+      .withIndex("by_user", (q) => q.eq("userId", args.userId))
+      .collect();
+
+    // Filter active only
+    return purchases.filter((p) => p.status === "active");
+  },
+});
+
+// Get purchase by user and API
+export const getByUserAndApi = query({
+  args: {
+    userId: v.id("users"),
+    apiId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("purchases")
+      .withIndex("by_user_and_api", (q) =>
+        q.eq("userId", args.userId).eq("apiId", args.apiId)
+      )
+      .first();
+  },
+});
+
+// Update purchase status
+export const updateStatus = mutation({
+  args: {
+    purchaseId: v.id("purchases"),
+    status: v.string(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.purchaseId, { status: args.status });
+  },
+});
+
+// Get all purchases (for admin)
+export const listAll = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("purchases").collect();
+  },
+});

package/backend/convex/schema.ts

@@ -0,0 +1,45 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  // Users
+  users: defineTable({
+    clerkId: v.optional(v.string()),
+    email: v.string(),
+    credits: v.number(), // in cents
+    createdAt: v.number(),
+  }).index("by_email", ["email"])
+    .index("by_clerkId", ["clerkId"]),
+
+  // API Purchases
+  purchases: defineTable({
+    userId: v.id("users"),
+    apiId: v.string(), // "46elks", "resend", etc
+    credentials: v.any(), // encrypted or reference
+    status: v.string(), // "active", "expired"
+    purchasedAt: v.number(),
+    expiresAt: v.optional(v.number()),
+  }).index("by_user", ["userId"])
+    .index("by_user_and_api", ["userId", "apiId"]),
+
+  // Transactions
+  transactions: defineTable({
+    userId: v.id("users"),
+    type: v.string(), // "credit_add", "api_purchase"
+    amount: v.number(),
+    description: v.string(),
+    createdAt: v.number(),
+  }).index("by_user", ["userId"]),
+
+  // BYOK - Bring Your Own Keys
+  apiKeys: defineTable({
+    userEmail: v.string(),
+    apiId: v.string(),
+    apiName: v.string(),
+    keyName: v.string(), // "API Key", "Secret Key", etc
+    keyValue: v.string(), // the actual key (encrypted in prod)
+    createdAt: v.number(),
+    lastUsed: v.optional(v.number()),
+  }).index("by_email", ["userEmail"])
+    .index("by_email_and_api", ["userEmail", "apiId"]),
+});

package/backend/convex/transactions.ts

@@ -0,0 +1,57 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// Log a transaction
+export const log = mutation({
+  args: {
+    userId: v.id("users"),
+    type: v.string(), // "credit_add", "api_purchase", "refund"
+    amount: v.number(),
+    description: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const transactionId = await ctx.db.insert("transactions", {
+      userId: args.userId,
+      type: args.type,
+      amount: args.amount,
+      description: args.description,
+      createdAt: Date.now(),
+    });
+
+    return transactionId;
+  },
+});
+
+// Get transaction history for user
+export const listByUser = query({
+  args: {
+    userId: v.id("users"),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const query = ctx.db
+      .query("transactions")
+      .withIndex("by_user", (q) => q.eq("userId", args.userId))
+      .order("desc");
+
+    if (args.limit) {
+      return await query.take(args.limit);
+    }
+    return await query.collect();
+  },
+});
+
+// Get all transactions (for admin)
+export const listAll = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const query = ctx.db.query("transactions").order("desc");
+    
+    if (args.limit) {
+      return await query.take(args.limit);
+    }
+    return await query.collect();
+  },
+});

package/backend/convex/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  /* This TypeScript project config describes the environment that
+   * Convex functions run in and is used to typecheck them.
+   * You can modify it, but some settings are required to use Convex.
+   */
+  "compilerOptions": {
+    /* These settings are not required by Convex and can be modified. */
+    "allowJs": true,
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+
+    /* These compiler options are required by Convex */
+    "target": "ESNext",
+    "lib": ["ES2021", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["./_generated"]
+}

package/backend/convex/users.ts

@@ -0,0 +1,94 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// Get user by email, create if not exists
+export const getOrCreate = mutation({
+  args: {
+    email: v.string(),
+    clerkId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Try to find existing user
+    const existing = await ctx.db
+      .query("users")
+      .withIndex("by_email", (q) => q.eq("email", args.email))
+      .first();
+
+    if (existing) {
+      // Update clerkId if provided and not set
+      if (args.clerkId && !existing.clerkId) {
+        await ctx.db.patch(existing._id, { clerkId: args.clerkId });
+      }
+      return existing._id;
+    }
+
+    // Create new user
+    const userId = await ctx.db.insert("users", {
+      email: args.email,
+      clerkId: args.clerkId,
+      credits: 0,
+      createdAt: Date.now(),
+    });
+
+    return userId;
+  },
+});
+
+// Add credits to user
+export const addCredits = mutation({
+  args: {
+    userId: v.id("users"),
+    amount: v.number(), // in cents, positive or negative
+  },
+  handler: async (ctx, args) => {
+    const user = await ctx.db.get(args.userId);
+    if (!user) {
+      throw new Error("User not found");
+    }
+
+    const newBalance = user.credits + args.amount;
+    if (newBalance < 0) {
+      throw new Error("Insufficient credits");
+    }
+
+    await ctx.db.patch(args.userId, { credits: newBalance });
+    return newBalance;
+  },
+});
+
+// Get current balance
+export const getBalance = query({
+  args: {
+    userId: v.id("users"),
+  },
+  handler: async (ctx, args) => {
+    const user = await ctx.db.get(args.userId);
+    if (!user) {
+      throw new Error("User not found");
+    }
+    return user.credits;
+  },
+});
+
+// Get user by ID
+export const get = query({
+  args: {
+    userId: v.id("users"),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.userId);
+  },
+});
+
+// Get user by email
+export const getByEmail = query({
+  args: {
+    email: v.string(),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("users")
+      .withIndex("by_email", (q) => q.eq("email", args.email))
+      .first();
+  },
+});