create-disposabl-app 0.1.0 → 0.1.2

package/dist/templates/default/packages/backend/convex/_generated/server.d.ts

@@ -0,0 +1,164 @@
+/* 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 {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+type Env = {
+  readonly CONVEX_CLOUD_URL: string;
+  readonly CONVEX_SITE_URL: string;
+  readonly AUTH_JWKS: string;
+  readonly AUTH_PRIVATE_KEY: string;
+};
+
+/**
+ * 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 declare const query: QueryBuilder<DataModel, "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 declare const internalQuery: QueryBuilder<DataModel, "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 declare const mutation: MutationBuilder<DataModel, "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 declare const internalMutation: MutationBuilder<DataModel, "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 declare const action: ActionBuilder<DataModel, "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 declare const internalAction: ActionBuilder<DataModel, "internal">;
+
+/**
+ * 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 declare const httpAction: HttpActionBuilder;
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+export declare const env: Env;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * This differs from the {@link MutationCtx} because all of the services are
+ * read-only.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/dist/templates/default/packages/backend/convex/_generated/server.js

@@ -0,0 +1,101 @@
+/* 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;
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+export const env = process.env;

package/dist/templates/default/packages/backend/convex/auth.config.ts

@@ -0,0 +1,14 @@
+import type { AuthConfig } from "convex/server";
+import { env } from "./_generated/server";
+
+export default {
+  providers: [
+    {
+      type: "customJwt",
+      applicationID: "convex",
+      issuer: env.CONVEX_SITE_URL,
+      jwks: `${env.CONVEX_SITE_URL}/auth/.well-known/jwks.json`,
+      algorithm: "RS256",
+    },
+  ],
+} satisfies AuthConfig;

package/dist/templates/default/packages/backend/convex/auth.ts

@@ -0,0 +1,15 @@
+import { setupUsernamePassword } from "@convex-dev/auth/methods/username-password/server";
+import { setupConvexAuth } from "@convex-dev/auth/server";
+import { components, internal } from "./_generated/api";
+
+const auth = setupConvexAuth({ component: components.auth });
+export const { signOut, refreshSession, isAuthenticated } = auth;
+
+export const {
+  signUpWithUsernamePassword,
+  signInWithUsernamePassword,
+  changePassword,
+} = setupUsernamePassword(auth, {
+  component: components.authPassword,
+  usernameComponent: components.authUsername,
+}).attachUserCallbacks({ createUser: internal.users.createUser });

package/dist/templates/default/packages/backend/convex/convex.config.ts

@@ -0,0 +1,30 @@
+import passwordProvider from "@convex-dev/auth/components/password/convex.config.js";
+import username from "@convex-dev/auth/components/username/convex.config.js";
+import auth from "@convex-dev/auth/convex.config.js";
+import mcp from "@convex-dev/mcp/convex.config.js";
+import staticHosting from "@convex-dev/static-hosting/convex.config";
+import workflow from "@convex-dev/workflow/convex.config";
+import { defineApp } from "convex/server";
+import { v } from "convex/values";
+
+const app = defineApp({
+  env: {
+    AUTH_PRIVATE_KEY: v.string(),
+    AUTH_JWKS: v.string(),
+  },
+});
+
+app.use(auth, {
+  httpPrefix: "/auth",
+  env: {
+    AUTH_PRIVATE_KEY: app.env.AUTH_PRIVATE_KEY,
+    AUTH_JWKS: app.env.AUTH_JWKS,
+  },
+});
+app.use(passwordProvider);
+app.use(username);
+app.use(staticHosting);
+app.use(mcp);
+app.use(workflow);
+
+export default app;

package/dist/templates/default/packages/backend/convex/http.ts

@@ -0,0 +1,5 @@
+import createHttpRouter from "@disposabl/disposabl-kit/server/http";
+
+const http = createHttpRouter();
+
+export default http;

package/dist/templates/default/packages/backend/convex/mcp.ts

@@ -0,0 +1,8 @@
+// Convex only exposes functions exported from the backend's convex/ directory.
+export {
+  authorize,
+  createApiKey,
+  getAuthRequest,
+  listConnections,
+  revokeConnection,
+} from "@disposabl/disposabl-kit/server/http";

package/dist/templates/default/packages/backend/convex/schema.ts

@@ -0,0 +1,10 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  users: defineTable({}),
+  todos: defineTable({ userId: v.string(), title: v.string() }).index(
+    "by_userId",
+    ["userId"],
+  ),
+});

package/dist/templates/default/packages/backend/convex/todos/index.ts

@@ -0,0 +1,26 @@
+import { getAuthUserId } from "@convex-dev/auth/server";
+import { ConvexError, v } from "convex/values";
+import { internal } from "../_generated/api";
+import type { Doc } from "../_generated/dataModel";
+import { query } from "../_generated/server";
+import schema from "../schema";
+
+export const list = query({
+  args: {},
+  returns: v.array(schema.doc("todos")),
+  handler: async (ctx): Promise<Doc<"todos">[]> => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) throw new ConvexError("Not signed in");
+    return await ctx.runQuery(internal.todos.internal.list, { userId });
+  },
+});
+
+export const get = query({
+  args: { id: v.id("todos") },
+  returns: v.union(schema.doc("todos"), v.null()),
+  handler: async (ctx, { id }): Promise<Doc<"todos"> | null> => {
+    const userId = await getAuthUserId(ctx);
+    if (!userId) throw new ConvexError("Not signed in");
+    return await ctx.runQuery(internal.todos.internal.get, { userId, id });
+  },
+});

package/dist/templates/default/packages/backend/convex/todos/internal.ts

@@ -0,0 +1,43 @@
+import {
+  identityFields,
+  internalMutation,
+  internalQuery,
+} from "@disposabl/disposabl-kit/server/lib/functions";
+import { ConvexError, v } from "convex/values";
+import schema from "../schema";
+
+export const create = internalMutation({
+  platforms: { mcp: true },
+  args: { ...identityFields, title: v.string() },
+  returns: v.id("todos"),
+  handler: async (ctx, { userId, title }) => {
+    const trimmed = title.trim();
+    if (!trimmed || trimmed.length > 500) {
+      throw new ConvexError("Todo title must contain 1 to 500 characters.");
+    }
+    return await ctx.db.insert("todos", { userId, title: trimmed });
+  },
+});
+
+export const list = internalQuery({
+  platforms: { mcp: true },
+  args: { ...identityFields },
+  returns: v.array(schema.doc("todos")),
+  handler: async (ctx, { userId }) => {
+    return await ctx.db
+      .query("todos")
+      .withIndex("by_userId", (q) => q.eq("userId", userId))
+      .order("desc")
+      .take(100);
+  },
+});
+
+export const get = internalQuery({
+  platforms: { mcp: true },
+  args: { ...identityFields, id: v.id("todos") },
+  returns: v.union(schema.doc("todos"), v.null()),
+  handler: async (ctx, { userId, id }) => {
+    const todo = await ctx.db.get("todos", id);
+    return todo?.userId === userId ? todo : null;
+  },
+});

package/dist/templates/default/packages/backend/convex/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  /* 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": {
+    "resolveJsonModule": true,
+    /* 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": ["ES2023", "dom"],
+    "types": ["node"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["./_generated"]
+}

package/dist/templates/default/packages/backend/convex/users.ts

@@ -0,0 +1,20 @@
+import { v } from "convex/values";
+import { internalMutation } from "@disposabl/disposabl-kit/server/lib/functions";
+
+/**
+ * Create the user row for a new password account and return its id. This
+ * example keeps no data in the row, but your app can put a profile here.
+ */
+export const createUser = internalMutation({
+  args: {
+    provider: v.object({
+      name: v.literal("password"),
+      accountId: v.string(),
+      profile: v.object({}),
+    }),
+  },
+  returns: v.id("users"),
+  handler: async (ctx) => {
+    return await ctx.db.insert("users", {});
+  },
+});

package/dist/templates/default/packages/backend/eslint.config.mjs

@@ -0,0 +1,62 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+
+import globals from "globals";
+import tsParser from "@typescript-eslint/parser";
+import js from "@eslint/js";
+import convexPlugin from "@convex-dev/eslint-plugin";
+
+import { FlatCompat } from "@eslint/eslintrc";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all,
+});
+
+export default defineConfig([
+  {
+    files: ["convex/**/*.ts"],
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+
+      parser: tsParser,
+
+      parserOptions: {
+        project: join(__dirname, "convex", "tsconfig.json"),
+      },
+    },
+
+    extends: compat.extends(
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended-type-checked",
+    ),
+
+    rules: {
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          varsIgnorePattern: "^_",
+          argsIgnorePattern: "^_",
+        },
+      ],
+
+      "@typescript-eslint/ban-ts-comment": "error",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unsafe-argument": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-member-access": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "@typescript-eslint/require-await": "off",
+    },
+  },
+  globalIgnores(["convex/_generated"]),
+  ...convexPlugin.configs.recommended,
+]);

package/dist/templates/default/packages/backend/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@disposabl/backend",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "dev": "convex dev",
+    "logs": "convex logs",
+    "typecheck": "tsc -p convex",
+    "lint": "bun run typecheck && eslint . --report-unused-disable-directives --max-warnings 0",
+    "format": "prettier --write 'convex/**/*.ts'"
+  },
+  "dependencies": {
+    "@boatdev/convex": "^0.1.0",
+    "@convex-dev/auth": "catalog:",
+    "@convex-dev/mcp": "catalog:",
+    "@convex-dev/static-hosting": "catalog:",
+    "@convex-dev/workflow": "^0.4.10",
+    "@disposabl/disposabl-kit": "workspace:*",
+    "@octokit/rest": "^22.0.1",
+    "@vercel/connect": "^2.5.2",
+    "convex": "catalog:",
+    "libsodium-wrappers": "^0.8.4"
+  },
+  "devDependencies": {
+    "@convex-dev/eslint-plugin": "^5.0.0",
+    "@eslint/eslintrc": "^3.3.6",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.13.3",
+    "@typescript-eslint/eslint-plugin": "^8.66.0",
+    "@typescript-eslint/parser": "^8.66.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "eslint": "^10.8.0",
+    "globals": "^17.9.0",
+    "typescript": "npm:@typescript/typescript6@^6.0.2"
+  }
+}