admin/the-pet-loft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ci: add Gitea CI workflow and track Convex generated types
Some checks failed
CI / Lint, Typecheck & Test (push) Failing after 2m11s
Details

Browse Source 
- Add .gitea/workflows/ci.yml — runs lint, typecheck, and tests on every push
- Remove convex/_generated from .gitignore and commit the generated files so CI
  has the type information it needs without requiring a live Convex backend

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
ianshaloom
2026-03-08 00:25:45 +03:00
parent 9cee6b0671
commit 51663df27d
7 changed files with 598 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

247
convex/_generated/api.d.ts vendored Normal file
View File

@@ -0,0 +1,247 @@
/* eslint-disable */
/**
* Generated `api` utility.
*
* THIS CODE IS AUTOMATICALLY GENERATED.
*
* To regenerate, run `npx convex dev`.
* @module
*/
import type * as addresses from "../addresses.js";
import type * as adminInvitations from "../adminInvitations.js";
import type * as carts from "../carts.js";
import type * as categories from "../categories.js";
import type * as checkout from "../checkout.js";
import type * as checkoutActions from "../checkoutActions.js";
import type * as emails from "../emails.js";
import type * as fulfillmentActions from "../fulfillmentActions.js";
import type * as http from "../http.js";
import type * as model_carts from "../model/carts.js";
import type * as model_categories from "../model/categories.js";
import type * as model_checkout from "../model/checkout.js";
import type * as model_orders from "../model/orders.js";
import type * as model_products from "../model/products.js";
import type * as model_shippo from "../model/shippo.js";
import type * as model_stripe from "../model/stripe.js";
import type * as model_users from "../model/users.js";
import type * as orders from "../orders.js";
import type * as products from "../products.js";
import type * as returnActions from "../returnActions.js";
import type * as reviews from "../reviews.js";
import type * as shippoWebhook from "../shippoWebhook.js";
import type * as stripeActions from "../stripeActions.js";
import type * as users from "../users.js";
import type * as wishlists from "../wishlists.js";
import type {
ApiFromModules,
FilterApi,
FunctionReference,
} from "convex/server";
declare const fullApi: ApiFromModules<{
addresses: typeof addresses;
adminInvitations: typeof adminInvitations;
carts: typeof carts;
categories: typeof categories;
checkout: typeof checkout;
checkoutActions: typeof checkoutActions;
emails: typeof emails;
fulfillmentActions: typeof fulfillmentActions;
http: typeof http;
"model/carts": typeof model_carts;
"model/categories": typeof model_categories;
"model/checkout": typeof model_checkout;
"model/orders": typeof model_orders;
"model/products": typeof model_products;
"model/shippo": typeof model_shippo;
"model/stripe": typeof model_stripe;
"model/users": typeof model_users;
orders: typeof orders;
products: typeof products;
returnActions: typeof returnActions;
reviews: typeof reviews;
shippoWebhook: typeof shippoWebhook;
stripeActions: typeof stripeActions;
users: typeof users;
wishlists: typeof wishlists;
}>;
/**
* 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: {
resend: {
lib: {
cancelEmail: FunctionReference<
"mutation",
"internal",
{ emailId: string },
null
>;
cleanupAbandonedEmails: FunctionReference<
"mutation",
"internal",
{ olderThan?: number },
null
>;
cleanupOldEmails: FunctionReference<
"mutation",
"internal",
{ olderThan?: number },
null
>;
createManualEmail: FunctionReference<
"mutation",
"internal",
{
from: string;
headers?: Array<{ name: string; value: string }>;
replyTo?: Array<string>;
subject: string;
to: Array<string> | string;
},
string
>;
get: FunctionReference<
"query",
"internal",
{ emailId: string },
{
bcc?: Array<string>;
bounced?: boolean;
cc?: Array<string>;
clicked?: boolean;
complained: boolean;
createdAt: number;
deliveryDelayed?: boolean;
errorMessage?: string;
failed?: boolean;
finalizedAt: number;
from: string;
headers?: Array<{ name: string; value: string }>;
html?: string;
opened: boolean;
replyTo: Array<string>;
resendId?: string;
segment: number;
status:
| "waiting"
| "queued"
| "cancelled"
| "sent"
| "delivered"
| "delivery_delayed"
| "bounced"
| "failed";
subject?: string;
template?: {
id: string;
variables?: Record<string, string | number>;
};
text?: string;
to: Array<string>;
} | null
>;
getStatus: FunctionReference<
"query",
"internal",
{ emailId: string },
{
bounced: boolean;
clicked: boolean;
complained: boolean;
deliveryDelayed: boolean;
errorMessage: string | null;
failed: boolean;
opened: boolean;
status:
| "waiting"
| "queued"
| "cancelled"
| "sent"
| "delivered"
| "delivery_delayed"
| "bounced"
| "failed";
} | null
>;
handleEmailEvent: FunctionReference<
"mutation",
"internal",
{ event: any },
null
>;
sendEmail: FunctionReference<
"mutation",
"internal",
{
bcc?: Array<string>;
cc?: Array<string>;
from: string;
headers?: Array<{ name: string; value: string }>;
html?: string;
options: {
apiKey: string;
initialBackoffMs: number;
onEmailEvent?: { fnHandle: string };
retryAttempts: number;
testMode: boolean;
};
replyTo?: Array<string>;
subject?: string;
template?: {
id: string;
variables?: Record<string, string | number>;
};
text?: string;
to: Array<string>;
},
string
>;
updateManualEmail: FunctionReference<
"mutation",
"internal",
{
emailId: string;
errorMessage?: string;
resendId?: string;
status:
| "waiting"
| "queued"
| "cancelled"
| "sent"
| "delivered"
| "delivery_delayed"
| "bounced"
| "failed";
},
null
>;
};
};
};

23
convex/_generated/api.js Normal file
View File

@@ -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();

60
convex/_generated/dataModel.d.ts vendored Normal file
View File

@@ -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>;

143
convex/_generated/server.d.ts vendored Normal file
View File

@@ -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>;

93
convex/_generated/server.js Normal file
View File

@@ -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;