@offworld/backend-api 0.1.0

package/dist/__tests__/push-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/references.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_generated/api.d.ts

@@ -0,0 +1,65 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as admin from "../admin.js";
+import type * as auth from "../auth.js";
+import type * as github from "../github.js";
+import type * as http from "../http.js";
+import type * as references from "../references.js";
+import type * as repository from "../repository.js";
+import type * as validation_github from "../validation/github.js";
+import type * as validation_push from "../validation/push.js";
+import type * as validation_referenceContent from "../validation/referenceContent.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+
+declare const fullApi: ApiFromModules<{
+  admin: typeof admin;
+  auth: typeof auth;
+  github: typeof github;
+  http: typeof http;
+  references: typeof references;
+  repository: typeof repository;
+  "validation/github": typeof validation_github;
+  "validation/push": typeof validation_push;
+  "validation/referenceContent": typeof validation_referenceContent;
+}>;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+>;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+>;
+
+export declare const components: {};

package/dist/_generated/api.js

@@ -0,0 +1,23 @@
+/* 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();

package/dist/_generated/dataModel.d.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(tableName, 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>;

package/dist/_generated/server.d.ts

@@ -0,0 +1,143 @@
+/* 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";
+
+/**
+ * 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;
+
+/**
+ * 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/_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/dist/admin.d.ts

@@ -0,0 +1,26 @@
+export declare const listAllReferences: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"reference">;
+    fullName: string;
+    pullCount: number;
+    generatedAt: string;
+    commitSha: string;
+    isVerified: boolean;
+}[]>>;
+export declare const listAllUsers: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"user">;
+    email: string;
+    name: string | undefined;
+    image: string | undefined;
+    createdAt: string;
+}[]>>;
+export declare const deleteReference: import("convex/server").RegisteredMutation<"public", {
+    fullName: string;
+}, Promise<{
+    success: boolean;
+}>>;
+export declare const toggleVerified: import("convex/server").RegisteredMutation<"public", {
+    fullName: string;
+}, Promise<{
+    success: boolean;
+    isVerified: boolean;
+}>>;

package/dist/auth.config.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    providers: ({
+        type: "customJwt";
+        issuer: string;
+        algorithm: "RS256";
+        jwks: string;
+        applicationID: string;
+    } | {
+        type: "customJwt";
+        issuer: string;
+        algorithm: "RS256";
+        jwks: string;
+        applicationID?: undefined;
+    })[];
+};
+export default _default;

package/dist/auth.d.ts

@@ -0,0 +1,39 @@
+import { type QueryCtx, type MutationCtx } from "./_generated/server";
+export declare function getAuthUser(ctx: QueryCtx | MutationCtx): Promise<{
+    _id: import("convex/values").GenericId<"user">;
+    _creationTime: number;
+    name?: string | undefined;
+    image?: string | undefined;
+    workosId: string;
+    email: string;
+    createdAt: string;
+} | null>;
+export declare const ensureUser: import("convex/server").RegisteredMutation<"public", {}, Promise<import("convex/values").GenericId<"user">>>;
+export declare const getCurrentUser: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"user">;
+    _creationTime: number;
+    name?: string | undefined;
+    image?: string | undefined;
+    workosId: string;
+    email: string;
+    createdAt: string;
+} | null>>;
+export declare const getCurrentUserSafe: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"user">;
+    _creationTime: number;
+    name?: string | undefined;
+    image?: string | undefined;
+    workosId: string;
+    email: string;
+    createdAt: string;
+} | null>>;
+export declare function requireAdmin(ctx: QueryCtx | MutationCtx): Promise<{
+    _id: import("convex/values").GenericId<"user">;
+    _creationTime: number;
+    name?: string | undefined;
+    image?: string | undefined;
+    workosId: string;
+    email: string;
+    createdAt: string;
+}>;
+export declare const isAdmin: import("convex/server").RegisteredQuery<"public", {}, Promise<boolean>>;

package/dist/convex.config.d.ts

@@ -0,0 +1,3 @@
+import type { AppDefinition } from "convex/server";
+declare const app: AppDefinition;
+export default app;

package/dist/github.d.ts

@@ -0,0 +1,36 @@
+export declare const fetchRepoMetadata: import("convex/server").RegisteredAction<"public", {
+    owner: string;
+    name: string;
+}, Promise<{
+    owner: string;
+    name: string;
+    fullName: string;
+    description: string | undefined;
+    stars: number;
+    language: string | undefined;
+    githubUrl: string;
+    defaultBranch: string;
+} | null>>;
+export declare const fetchOwnerInfo: import("convex/server").RegisteredAction<"public", {
+    owner: string;
+}, Promise<{
+    login: string;
+    name: string;
+    avatarUrl: string;
+    bio: string | undefined;
+    type: "user" | "organization";
+    publicRepos: number;
+    followers: number;
+    htmlUrl: string;
+} | null>>;
+export declare const fetchOwnerRepos: import("convex/server").RegisteredAction<"public", {
+    perPage?: number | undefined;
+    owner: string;
+}, Promise<{
+    owner: string;
+    name: string;
+    fullName: string;
+    description: string | undefined;
+    stars: number;
+    language: string | undefined;
+}[] | null>>;

package/dist/healthCheck.d.ts

@@ -0,0 +1,2 @@
+import type { QueryBuilder } from "convex/server";
+export declare const get: ReturnType<QueryBuilder<any, "public">>;

package/dist/http.d.ts

@@ -0,0 +1,2 @@
+declare const http: import("convex/server").HttpRouter;
+export default http;

package/dist/references.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Reference Convex Functions
+ * Public queries/mutations for CLI and web app
+ */
+/**
+ * Get reference by repository fullName (public)
+ * Display reference on web
+ */
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    fullName: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"reference">;
+    _creationTime: number;
+    workosId?: string | undefined;
+    repositoryId: import("convex/values").GenericId<"repository">;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+    pullCount: number;
+    isVerified: boolean;
+} | null>>;
+/**
+ * Get reference by repository fullName + referenceName (public)
+ * Display specific reference on web
+ */
+export declare const getByName: import("convex/server").RegisteredQuery<"public", {
+    fullName: string;
+    referenceName: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"reference">;
+    _creationTime: number;
+    workosId?: string | undefined;
+    repositoryId: import("convex/values").GenericId<"repository">;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+    pullCount: number;
+    isVerified: boolean;
+} | null>>;
+/**
+ * List all references for a repository (public)
+ */
+export declare const listByRepo: import("convex/server").RegisteredQuery<"public", {
+    fullName: string;
+}, Promise<{
+    referenceName: string;
+    referenceDescription: string;
+    generatedAt: string;
+    commitSha: string;
+    pullCount: number;
+    isVerified: boolean;
+}[]>>;
+/**
+ * List all references sorted by pull count (public)
+ * Repo directory/explore page
+ */
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}, Promise<{
+    fullName: string;
+    pullCount: number;
+    generatedAt: string;
+    commitSha: string;
+    isVerified: boolean;
+}[]>>;
+/**
+ * List references pushed by the current user
+ */
+export declare const listByCurrentUser: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    fullName: string;
+    owner: string;
+    name: string;
+    referenceName: string;
+    referenceDescription: string;
+    pullCount: number;
+    generatedAt: string;
+    commitSha: string;
+    isVerified: boolean;
+}[]>>;
+/**
+ * Fetch reference for CLI pull (no pull count tracking)
+ */
+export declare const pull: import("convex/server").RegisteredQuery<"public", {
+    referenceName?: string | undefined;
+    fullName: string;
+}, Promise<{
+    fullName: string;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+} | null>>;
+/**
+ * Lightweight existence check for CLI
+ */
+export declare const check: import("convex/server").RegisteredQuery<"public", {
+    referenceName?: string | undefined;
+    fullName: string;
+}, Promise<{
+    exists: false;
+    commitSha?: undefined;
+    generatedAt?: undefined;
+} | {
+    exists: true;
+    commitSha: string;
+    generatedAt: string;
+}>>;
+export type PushError = "auth_required" | "invalid_input" | "invalid_reference" | "repo_not_found" | "low_stars" | "private_repo" | "commit_not_found" | "commit_already_exists" | "rate_limit" | "github_error";
+export type PushResult = {
+    success: true;
+} | {
+    success: false;
+    error: PushError;
+    message?: string;
+};
+/**
+ * Push reference - public action with full validation
+ */
+export declare const push: import("convex/server").RegisteredAction<"public", {
+    fullName: string;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+}, Promise<PushResult>>;
+/**
+ * Internal mutation - DB operations only, not directly callable
+ */
+export declare const pushInternal: import("convex/server").RegisteredMutation<"internal", {
+    canonicalFullName?: string | undefined;
+    repoStars?: number | undefined;
+    repoDescription?: string | undefined;
+    fullName: string;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+    workosId: string;
+}, Promise<PushResult>>;
+/**
+ * Record a pull event - increments pullCount for display on repo pages
+ */
+export declare const recordPull: import("convex/server").RegisteredMutation<"public", {
+    referenceName?: string | undefined;
+    fullName: string;
+}, Promise<void>>;

package/dist/repository.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Repository Convex Functions
+ * Queries for GitHub repository metadata
+ */
+/**
+ * Get repository by fullName
+ */
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    fullName: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"repository">;
+    _creationTime: number;
+    description?: string | undefined;
+    language?: string | undefined;
+    fullName: string;
+    fullNameLower: string;
+    owner: string;
+    name: string;
+    stars: number;
+    defaultBranch: string;
+    githubUrl: string;
+    fetchedAt: string;
+} | null>>;
+/**
+ * List repositories by owner
+ */
+export declare const listByOwner: import("convex/server").RegisteredQuery<"public", {
+    owner: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"repository">;
+    _creationTime: number;
+    description?: string | undefined;
+    language?: string | undefined;
+    fullName: string;
+    fullNameLower: string;
+    owner: string;
+    name: string;
+    stars: number;
+    defaultBranch: string;
+    githubUrl: string;
+    fetchedAt: string;
+}[]>>;
+/**
+ * List repositories sorted by stars (for explore page)
+ */
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    limit?: number | undefined;
+}, Promise<{
+    _id: import("convex/values").GenericId<"repository">;
+    _creationTime: number;
+    description?: string | undefined;
+    language?: string | undefined;
+    fullName: string;
+    fullNameLower: string;
+    owner: string;
+    name: string;
+    stars: number;
+    defaultBranch: string;
+    githubUrl: string;
+    fetchedAt: string;
+}[]>>;
+/**
+ * List recently indexed repositories (for homepage carousel)
+ */
+export declare const listRecent: import("convex/server").RegisteredQuery<"public", {
+    limit?: number | undefined;
+}, Promise<{
+    _id: import("convex/values").GenericId<"repository">;
+    _creationTime: number;
+    description?: string | undefined;
+    language?: string | undefined;
+    fullName: string;
+    fullNameLower: string;
+    owner: string;
+    name: string;
+    stars: number;
+    defaultBranch: string;
+    githubUrl: string;
+    fetchedAt: string;
+}[]>>;
+/**
+ * Upsert repository (internal - called after fetching from GitHub)
+ */
+export declare const upsert: import("convex/server").RegisteredMutation<"internal", {
+    description?: string | undefined;
+    language?: string | undefined;
+    fullName: string;
+    owner: string;
+    name: string;
+    stars: number;
+    defaultBranch: string;
+    githubUrl: string;
+}, Promise<import("convex/values").GenericId<"repository">>>;

package/dist/schema.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Offworld Backend Schema
+ * Convex schema for reference storage
+ */
+declare const _default: import("convex/server").SchemaDefinition<{
+    repository: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        description?: string | undefined;
+        language?: string | undefined;
+        fullName: string;
+        fullNameLower: string;
+        owner: string;
+        name: string;
+        stars: number;
+        defaultBranch: string;
+        githubUrl: string;
+        fetchedAt: string;
+    }, {
+        fullName: import("convex/values").VString<string, "required">;
+        fullNameLower: import("convex/values").VString<string, "required">;
+        owner: import("convex/values").VString<string, "required">;
+        name: import("convex/values").VString<string, "required">;
+        description: import("convex/values").VString<string | undefined, "optional">;
+        stars: import("convex/values").VFloat64<number, "required">;
+        language: import("convex/values").VString<string | undefined, "optional">;
+        defaultBranch: import("convex/values").VString<string, "required">;
+        githubUrl: import("convex/values").VString<string, "required">;
+        fetchedAt: import("convex/values").VString<string, "required">;
+    }, "required", "fullName" | "fullNameLower" | "owner" | "name" | "description" | "stars" | "language" | "defaultBranch" | "githubUrl" | "fetchedAt">, {
+        by_fullName: ["fullName", "_creationTime"];
+        by_fullNameLower: ["fullNameLower", "_creationTime"];
+        by_owner: ["owner", "_creationTime"];
+        by_stars: ["stars", "_creationTime"];
+        by_fetchedAt: ["fetchedAt", "_creationTime"];
+    }, {}, {}>;
+    reference: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        workosId?: string | undefined;
+        repositoryId: import("convex/values").GenericId<"repository">;
+        referenceName: string;
+        referenceDescription: string;
+        referenceContent: string;
+        commitSha: string;
+        generatedAt: string;
+        pullCount: number;
+        isVerified: boolean;
+    }, {
+        repositoryId: import("convex/values").VId<import("convex/values").GenericId<"repository">, "required">;
+        referenceName: import("convex/values").VString<string, "required">;
+        referenceDescription: import("convex/values").VString<string, "required">;
+        referenceContent: import("convex/values").VString<string, "required">;
+        commitSha: import("convex/values").VString<string, "required">;
+        generatedAt: import("convex/values").VString<string, "required">;
+        pullCount: import("convex/values").VFloat64<number, "required">;
+        isVerified: import("convex/values").VBoolean<boolean, "required">;
+        workosId: import("convex/values").VString<string | undefined, "optional">;
+    }, "required", "repositoryId" | "referenceName" | "referenceDescription" | "referenceContent" | "commitSha" | "generatedAt" | "pullCount" | "isVerified" | "workosId">, {
+        by_repositoryId: ["repositoryId", "_creationTime"];
+        by_repositoryId_referenceName: ["repositoryId", "referenceName", "_creationTime"];
+        by_repositoryId_commitSha: ["repositoryId", "commitSha", "_creationTime"];
+        by_pullCount: ["pullCount", "_creationTime"];
+        by_generatedAt: ["generatedAt", "_creationTime"];
+        by_workosId: ["workosId", "_creationTime"];
+    }, {}, {}>;
+    pushLog: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        fullName: string;
+        commitSha: string;
+        workosId: string;
+        pushedAt: string;
+    }, {
+        fullName: import("convex/values").VString<string, "required">;
+        workosId: import("convex/values").VString<string, "required">;
+        pushedAt: import("convex/values").VString<string, "required">;
+        commitSha: import("convex/values").VString<string, "required">;
+    }, "required", "fullName" | "commitSha" | "workosId" | "pushedAt">, {
+        by_repo_date: ["fullName", "pushedAt", "_creationTime"];
+        by_workos_date: ["workosId", "pushedAt", "_creationTime"];
+    }, {}, {}>;
+    user: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        name?: string | undefined;
+        image?: string | undefined;
+        workosId: string;
+        email: string;
+        createdAt: string;
+    }, {
+        workosId: import("convex/values").VString<string, "required">;
+        email: import("convex/values").VString<string, "required">;
+        name: import("convex/values").VString<string | undefined, "optional">;
+        image: import("convex/values").VString<string | undefined, "optional">;
+        createdAt: import("convex/values").VString<string, "required">;
+    }, "required", "name" | "workosId" | "email" | "image" | "createdAt">, {
+        by_email: ["email", "_creationTime"];
+        by_workosId: ["workosId", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;

package/dist/validation/github.d.ts

@@ -0,0 +1,19 @@
+export interface RepoValidationResult {
+    valid: boolean;
+    error?: string;
+    stars?: number;
+    description?: string;
+    canonicalFullName?: string;
+}
+export interface CommitValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * Verify repo exists and has minimum stars
+ */
+export declare function validateRepo(fullName: string): Promise<RepoValidationResult>;
+/**
+ * Verify commit exists in repo
+ */
+export declare function validateCommit(fullName: string, commitSha: string): Promise<CommitValidationResult>;

package/dist/validation/push.d.ts

@@ -0,0 +1,36 @@
+export declare const FULLNAME_MIN = 3;
+export declare const FULLNAME_MAX = 200;
+export declare const SKILLNAME_MIN = 2;
+export declare const SKILLNAME_MAX = 80;
+export declare const DESCRIPTION_MAX = 200;
+export declare const CONTENT_MIN = 500;
+export declare const CONTENT_MAX = 200000;
+export declare const COMMIT_SHA_LENGTH = 40;
+export declare const FULLNAME_PATTERN: RegExp;
+export declare const SKILLNAME_PATTERN: RegExp;
+export declare const COMMIT_SHA_PATTERN: RegExp;
+export declare const pushArgs: {
+    fullName: import("convex/values").VString<string, "required">;
+    referenceName: import("convex/values").VString<string, "required">;
+    referenceDescription: import("convex/values").VString<string, "required">;
+    referenceContent: import("convex/values").VString<string, "required">;
+    commitSha: import("convex/values").VString<string, "required">;
+    generatedAt: import("convex/values").VString<string, "required">;
+};
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    field?: string;
+}
+/**
+ * Validates push arguments at runtime
+ * Returns first validation error or { valid: true }
+ */
+export declare function validatePushArgs(args: {
+    fullName: string;
+    referenceName: string;
+    referenceDescription: string;
+    referenceContent: string;
+    commitSha: string;
+    generatedAt: string;
+}): ValidationResult;

package/dist/validation/referenceContent.d.ts

@@ -0,0 +1,7 @@
+export interface ContentValidationResult {
+    valid: boolean;
+    error?: string;
+    name?: string;
+    description?: string;
+}
+export declare function validateReferenceContent(content: string): ContentValidationResult;

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@offworld/backend-api",
+	"version": "0.1.0",
+	"description": "Generated Convex API types for Offworld",
+	"license": "MIT",
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"exports": {
+		"./api": {
+			"types": "./dist/_generated/api.d.ts",
+			"import": "./dist/_generated/api.js"
+		},
+		"./server": {
+			"types": "./dist/_generated/server.d.ts",
+			"import": "./dist/_generated/server.js"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.json && bun run ./scripts/copy-generated.ts",
+		"prepublishOnly": "bun run build"
+	},
+	"dependencies": {
+		"convex": "catalog:"
+	},
+	"devDependencies": {
+		"typescript": "catalog:"
+	}
+}