franpcode/create-better-t-stack
1
0
Fork 0
mirror of https://github.com/FranP-code/create-better-t-stack.git synced 2025-10-12 23:52:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix

Browse Source
This commit is contained in:
Aman Varshney
2025-08-03 03:20:09 +05:30
parent fef7f6b5e2
commit ead88a78d1
6 changed files with 577 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
packages/backend/.gitignore vendored
View File

@@ -1,3 +1,2 @@
.env.local
_generated

257
packages/backend/convex/_generated/api.d.ts vendored Normal file
View File

@@ -0,0 +1,257 @@
/* eslint-disable */
/**
* Generated `api` utility.
*
* THIS CODE IS AUTOMATICALLY GENERATED.
*
* To regenerate, run `npx convex dev`.
* @module
*/
import type * as healthCheck from "../healthCheck.js";
import type * as http from "../http.js";
import type * as stats from "../stats.js";
import type {
ApiFromModules,
FilterApi,
FunctionReference,
} from "convex/server";
/**
* A utility for referencing Convex functions in your app's API.
*
* Usage:
* ```js
* const myFunctionReference = api.myModule.myFunction;
* ```
*/
declare const fullApi: ApiFromModules<{
healthCheck: typeof healthCheck;
http: typeof http;
stats: typeof stats;
}>;
declare const fullApiWithMounts: typeof fullApi;
export declare const api: FilterApi<
typeof fullApiWithMounts,
FunctionReference<any, "public">
>;
export declare const internal: FilterApi<
typeof fullApiWithMounts,
FunctionReference<any, "internal">
>;
export declare const components: {
ossStats: {
github: {
getGithubOwners: FunctionReference<
"query",
"internal",
{ owners: Array<string> },
Array<null | {
contributorCount: number;
dependentCount: number;
dependentCountPrevious?: { count: number; updatedAt: number };
dependentCountUpdatedAt?: number;
name: string;
nameNormalized: string;
starCount: number;
updatedAt: number;
}>
>;
getGithubRepo: FunctionReference<
"query",
"internal",
{ name: string },
null | {
contributorCount: number;
dependentCount: number;
dependentCountPrevious?: { count: number; updatedAt: number };
dependentCountUpdatedAt?: number;
name: string;
nameNormalized: string;
owner: string;
ownerNormalized: string;
starCount: number;
updatedAt: number;
}
>;
getGithubRepos: FunctionReference<
"query",
"internal",
{ names: Array<string> },
Array<null | {
contributorCount: number;
dependentCount: number;
dependentCountPrevious?: { count: number; updatedAt: number };
dependentCountUpdatedAt?: number;
name: string;
nameNormalized: string;
owner: string;
ownerNormalized: string;
starCount: number;
updatedAt: number;
}>
>;
updateGithubOwner: FunctionReference<
"mutation",
"internal",
{ name: string },
any
>;
updateGithubOwnerStats: FunctionReference<
"action",
"internal",
{ githubAccessToken: string; owner: string; page?: number },
any
>;
updateGithubRepoStars: FunctionReference<
"mutation",
"internal",
{ name: string; owner: string; starCount: number },
any
>;
updateGithubRepoStats: FunctionReference<
"action",
"internal",
{ githubAccessToken: string; repo: string },
any
>;
updateGithubRepos: FunctionReference<
"mutation",
"internal",
{
repos: Array<{
contributorCount: number;
dependentCount: number;
name: string;
owner: string;
starCount: number;
}>;
},
any
>;
};
lib: {
clearAndSync: FunctionReference<
"action",
"internal",
{
githubAccessToken: string;
githubOwners?: Array<string>;
githubRepos?: Array<string>;
minStars?: number;
npmOrgs?: Array<string>;
npmPackages?: Array<string>;
},
any
>;
clearPage: FunctionReference<
"mutation",
"internal",
{ tableName: "githubRepos" | "npmPackages" },
{ isDone: boolean }
>;
clearTable: FunctionReference<
"action",
"internal",
{ tableName: "githubRepos" | "npmPackages" },
null
>;
sync: FunctionReference<
"action",
"internal",
{
githubAccessToken: string;
githubOwners?: Array<string>;
githubRepos?: Array<string>;
minStars?: number;
npmOrgs?: Array<string>;
npmPackages?: Array<string>;
},
null
>;
};
npm: {
getNpmOrgs: FunctionReference<
"query",
"internal",
{ names: Array<string> },
Array<null | {
dayOfWeekAverages: Array<number>;
downloadCount: number;
downloadCountUpdatedAt: number;
name: string;
updatedAt: number;
}>
>;
getNpmPackage: FunctionReference<
"query",
"internal",
{ name: string },
null | {
dayOfWeekAverages: Array<number>;
downloadCount: number;
downloadCountUpdatedAt?: number;
name: string;
org?: string;
updatedAt: number;
}
>;
getNpmPackages: FunctionReference<
"query",
"internal",
{ names: Array<string> },
{
dayOfWeekAverages: Array<number>;
downloadCount: number;
downloadCountUpdatedAt: number;
updatedAt: number;
}
>;
updateNpmOrg: FunctionReference<
"mutation",
"internal",
{ name: string },
any
>;
updateNpmOrgStats: FunctionReference<
"action",
"internal",
{ org: string; page?: number },
any
>;
updateNpmPackage: FunctionReference<
"mutation",
"internal",
{
dayOfWeekAverages: Array<number>;
downloadCount: number;
name: string;
},
any
>;
updateNpmPackageStats: FunctionReference<
"action",
"internal",
{ name: string },
any
>;
updateNpmPackagesForOrg: FunctionReference<
"mutation",
"internal",
{
org: string;
packages: Array<{
dayOfWeekAverages: Array<number>;
downloadCount: number;
isNotFound?: boolean;
name: string;
}>;
},
any
>;
};
};
};

23
packages/backend/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();

58
packages/backend/convex/_generated/dataModel.d.ts vendored Normal file
View File

@@ -0,0 +1,58 @@
/* eslint-disable */
/**
* Generated data model types.
*
* THIS CODE IS AUTOMATICALLY GENERATED.
*
* To regenerate, run `npx convex dev`.
* @module
*/
import { AnyDataModel } from "convex/server";
import type { GenericId } from "convex/values";
/**
* No `schema.ts` file found!
*
* This generated code has permissive types like `Doc = any` because
* Convex doesn't know your schema. If you'd like more type safety, see
* https://docs.convex.dev/using/schemas for instructions on how to add a
* schema file.
*
* After you change a schema, rerun codegen with `npx convex dev`.
*/
/**
* The names of all of your Convex tables.
*/
export type TableNames = string;
/**
* The type of a document stored in Convex.
*/
export type Doc = any;
/**
* 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(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.
*/
export type Id<TableName extends TableNames = TableNames> =
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 = AnyDataModel;

149
packages/backend/convex/_generated/server.d.ts vendored Normal file
View File

@@ -0,0 +1,149 @@
/* 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,
AnyComponents,
HttpActionBuilder,
MutationBuilder,
QueryBuilder,
GenericActionCtx,
GenericMutationCtx,
GenericQueryCtx,
GenericDatabaseReader,
GenericDatabaseWriter,
FunctionReference,
} from "convex/server";
import type { DataModel } from "./dataModel.js";
type GenericCtx =
| GenericActionCtx<DataModel>
| GenericMutationCtx<DataModel>
| GenericQueryCtx<DataModel>;
/**
* 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.
*
* This 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 action in `convex/http.js`.
*
* @param func - The function. It receives an {@link ActionCtx} as its first argument.
* @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>;

90
packages/backend/convex/_generated/server.js Normal file
View File

@@ -0,0 +1,90 @@
/* 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,
componentsGeneric,
} 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 a Convex HTTP action.
*
* @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
* as its second.
* @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
*/
export const httpAction = httpActionGeneric;