@xixixao/convex-migrations 0.3.1-alpha.1

package/dist/client/index.d.ts

@@ -0,0 +1,390 @@
+import { type DocumentByName, type FunctionReference, type GenericActionCtx, type GenericDataModel, type GenericMutationCtx, type GenericQueryCtx, type MutationBuilder, type NamedTableInfo, type OrderedQuery, type QueryInitializer, type RegisteredMutation, type TableNamesInDataModel } from "convex/server";
+import { type MigrationArgs, type MigrationResult, type MigrationStatus } from "../shared.js";
+export type { MigrationArgs, MigrationResult, MigrationStatus };
+import { type GenericId, type GenericValidator, type Infer, type ObjectType, type PropertyValidators, type Validator } from "convex/values";
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { MigrationFunctionHandle } from "../component/lib.js";
+export declare const DEFAULT_BATCH_SIZE = 100;
+/**
+ * Infer the TypeScript type from an args validator definition.
+ * - If a single Validator (e.g. `v.object({...})`), use `Infer<T>`.
+ * - If PropertyValidators (e.g. `{ tag: v.string() }`), use `ObjectType<T>`.
+ * - If void/undefined (no args defined), the args type is `undefined`.
+ */
+type InferMigrationArgs<T> = T extends Validator<any, any, any> ? Infer<T> : T extends PropertyValidators ? ObjectType<T> : undefined;
+export declare class Migrations<DataModel extends GenericDataModel> {
+    component: ComponentApi;
+    options?: {
+        /**
+         * Uses the internal mutation to run the migration.
+         * This also provides the types for your tables.
+         * ```ts
+         * import { internalMutation } from "./_generated/server.js";
+         * ```
+         */
+        internalMutation?: MutationBuilder<DataModel, "internal">;
+        /**
+         * How many documents to process in a batch.
+         * Your migrateOne function will be called for each document in a batch in
+         * a single transaction.
+         */
+        defaultBatchSize?: number;
+        /**
+         * Prefix to add to the function name when running migrations.
+         * For example, if you have a function named "foo" in a file
+         * "convex/bar/baz.ts", you can set {migrationsLocationPrefix: "bar/baz:"}
+         * and then run:
+         * ```sh
+         * npx convex run migrations:run '{"fn": "foo"}'
+         * ```
+         */
+        migrationsLocationPrefix?: string;
+    } | undefined;
+    /**
+     * Makes the migration wrapper, with types for your own tables.
+     *
+     * It will keep track of migration state.
+     * Add in convex/migrations.ts for example:
+     * ```ts
+     * import { Migrations } from "@convex-dev/migrations";
+     * import { components } from "./_generated/api.js";
+     * import { internalMutation } from "./_generated/server";
+     *
+     * export const migrations = new Migrations(components.migrations, { internalMutation });
+     * // the private mutation to run migrations.
+     * export const run = migrations.runner();
+     *
+     * export const myMigration = migrations.define({
+     *  table: "users",
+     *  migrateOne: async (ctx, doc) => {
+     *    await ctx.db.patch(doc._id, { someField: "value" });
+     *  }
+     * });
+     * ```
+     * You can then run it from the CLI or dashboard:
+     * ```sh
+     * npx convex run migrations:run '{"fn": "migrations:myMigration"}'
+     * ```
+     * For starting a migration from code, see {@link runOne}/{@link runSerially}.
+     * @param component - The migrations component. It will be on components.migrations
+     * after being configured in in convex.config.js.
+     * @param options - Configure options and set the internalMutation to use.
+     */
+    constructor(component: ComponentApi, options?: {
+        /**
+         * Uses the internal mutation to run the migration.
+         * This also provides the types for your tables.
+         * ```ts
+         * import { internalMutation } from "./_generated/server.js";
+         * ```
+         */
+        internalMutation?: MutationBuilder<DataModel, "internal">;
+        /**
+         * How many documents to process in a batch.
+         * Your migrateOne function will be called for each document in a batch in
+         * a single transaction.
+         */
+        defaultBatchSize?: number;
+        /**
+         * Prefix to add to the function name when running migrations.
+         * For example, if you have a function named "foo" in a file
+         * "convex/bar/baz.ts", you can set {migrationsLocationPrefix: "bar/baz:"}
+         * and then run:
+         * ```sh
+         * npx convex run migrations:run '{"fn": "foo"}'
+         * ```
+         */
+        migrationsLocationPrefix?: string;
+    } | undefined);
+    /**
+     * Creates a migration runner that can be called from the CLI or dashboard.
+     *
+     * For starting a migration from code, see {@link runOne}/{@link runSerially}.
+     *
+     * It can be created for a specific migration:
+     * ```ts
+     * export const runMyMigration = runner(internal.migrations.myMigration);
+     * ```
+     * CLI: `npx convex run migrations:runMyMigration`
+     *
+     * Or for any migration:
+     * ```ts
+     * export const run = runner();
+     * ```
+     * CLI: `npx convex run migrations:run '{"fn": "migrations:myMigration"}'`
+     *
+     * Where `myMigration` is the name of the migration function, defined in
+     * "convex/migrations.ts" along with the run function.
+     *
+     * @param specificMigration If you want a migration runner for one migration,
+     * pass in the migration function reference like `internal.migrations.foo`.
+     * Otherwise it will be a generic runner that requires the migration name.
+     * @returns An internal mutation,
+     */
+    runner(specificMigrationOrSeries?: MigrationFunctionReference | MigrationFunctionReference[]): RegisteredMutation<"internal", {
+        args?: any;
+        fn?: string | undefined;
+        cursor?: string | null | undefined;
+        batchSize?: number | undefined;
+        dryRun?: boolean | undefined;
+        next?: string[] | undefined;
+    }, Promise<Record<string, unknown>>>;
+    private _runInteractive;
+    /**
+     * Use this to wrap a mutation that will be run over all documents in a table.
+     * Your mutation only needs to handle changing one document at a time,
+     * passed into migrateOne.
+     * Optionally specify a custom batch size to override the default (100).
+     *
+     * In convex/migrations.ts for example:
+     * ```ts
+     * export const foo = migrations.define({
+     *  table: "users",
+     *  migrateOne: async (ctx, doc) => {
+     *   await ctx.db.patch(doc._id, { someField: "value" });
+     *  },
+     * });
+     * ```
+     *
+     * You can run this manually from the CLI or dashboard:
+     * ```sh
+     * # Start or resume a migration. No-ops if it's already done:
+     * npx convex run migrations:run '{"fn": "migrations:foo"}'
+     *
+     * # Restart a migration from a cursor (null is from the beginning):
+     * npx convex run migrations:run '{"fn": "migrations:foo", "cursor": null }'
+     *
+     * # Dry run - runs one batch but doesn't schedule or commit changes.
+     * # so you can see what it would do without committing the transaction.
+     * npx convex run migrations:run '{"fn": "migrations:foo", "dryRun": true}'
+     * # or
+     * npx convex run migrations:myMigration '{"dryRun": true}'
+     *
+     * # Run many migrations serially:
+     * npx convex run migrations:run '{"fn": "migrations:foo", "next": ["migrations:bar", "migrations:baz"] }'
+     * ```
+     *
+     * The fn is the string form of the function reference. See:
+     * https://docs.convex.dev/functions/query-functions#query-names
+     *
+     * See {@link runOne} and {@link runSerially} for programmatic use.
+     *
+     * @param table - The table to run the migration over.
+     * @param migrateOne - The function to run on each document.
+     * @param batchSize - The number of documents to process in a batch.
+     *   If not set, defaults to the value passed to makeMigration,
+     *   or {@link DEFAULT_BATCH_SIZE}. Overriden by arg at runtime if supplied.
+     * @param parallelize - If true, each migration batch will be run in parallel.
+     * @returns An internal mutation that runs the migration.
+     */
+    define<TableName extends TableNamesInDataModel<DataModel>, ArgsValidator extends GenericValidator | PropertyValidators | void = void>({ table, migrateOne, customRange, batchSize: functionDefaultBatchSize, parallelize, args: defineArgs, }: {
+        table: TableName;
+        migrateOne: (ctx: GenericMutationCtx<DataModel>, doc: DocumentByName<DataModel, TableName> & {
+            _id: GenericId<TableName>;
+        }, args: InferMigrationArgs<ArgsValidator>) => void | Partial<DocumentByName<DataModel, TableName>> | Promise<Partial<DocumentByName<DataModel, TableName>> | void>;
+        customRange?: (q: QueryInitializer<NamedTableInfo<DataModel, TableName>>, args: InferMigrationArgs<ArgsValidator>) => OrderedQuery<NamedTableInfo<DataModel, TableName>>;
+        batchSize?: number;
+        parallelize?: boolean;
+        args?: ArgsValidator;
+    }): RegisteredMutation<"internal", {
+        args?: any;
+        fn?: string | undefined;
+        cursor?: string | null | undefined;
+        batchSize?: number | undefined;
+        dryRun?: boolean | undefined;
+        next?: string[] | undefined;
+    }, Promise<any>>;
+    /**
+     * Start a migration from a server function via a function reference.
+     *
+     * ```ts
+     * const migrations = new Migrations(components.migrations, { internalMutation });
+     *
+     * // in a mutation or action:
+     *   await migrations.runOne(ctx, internal.migrations.myMigration, {
+     *     cursor: null, // optional override
+     *     batchSize: 10, // optional override
+     *   });
+     * ```
+     *
+     * Overrides any options you passed in, such as resetting the cursor.
+     * If it's already in progress, it will no-op.
+     * If you run a migration that had previously failed which was part of a series,
+     * it will not resume the series.
+     * To resume a series, call the series again: {@link Migrations.runSerially}.
+     *
+     * Note: It's up to you to determine if it's safe to run a migration while
+     * others are in progress. It won't run multiple instance of the same migration
+     * but it currently allows running multiple migrations on the same table.
+     *
+     * @param ctx Context from a mutation or action. Needs `runMutation`.
+     * @param fnRef The migration function to run. Like `internal.migrations.foo`.
+     * @param opts Options to start the migration.
+     * @param opts.cursor The cursor to start from.
+     *   null: start from the beginning.
+     *   undefined: start or resume from where it failed. If done, it won't restart.
+     * @param opts.batchSize The number of documents to process in a batch.
+     * @param opts.dryRun If true, it will run a batch and then throw an error.
+     *   It's helpful to see what it would do without committing the transaction.
+     */
+    runOne(ctx: MutationCtx | ActionCtx, fnRef: MigrationFunctionReference, opts?: {
+        cursor?: string | null;
+        batchSize?: number;
+        dryRun?: boolean;
+        args?: any;
+    }): Promise<{
+        batchSize?: number;
+        cursor?: string | null;
+        error?: string;
+        isDone: boolean;
+        latestEnd?: number;
+        latestStart: number;
+        name: string;
+        next?: Array<string>;
+        processed: number;
+        state: "inProgress" | "success" | "failed" | "canceled" | "unknown";
+    }>;
+    /**
+     * Start a series of migrations, running one a time. Each call starts a series.
+     *
+     * ```ts
+     * const migrations = new Migrations(components.migrations, { internalMutation });
+     *
+     * // in a mutation or action:
+     *   await migrations.runSerially(ctx, [
+     *    internal.migrations.myMigration,
+     *    internal.migrations.myOtherMigration,
+     *   ]);
+     * ```
+     *
+     * It runs one batch at a time currently.
+     * If a migration has previously completed it will skip it.
+     * If a migration had partial progress, it will resume from where it left off.
+     * If a migration is already in progress when attempted, it will no-op.
+     * If a migration fails or is canceled, it will stop executing and NOT execute
+     * any subsequent migrations in the series. Call the series again to retry.
+     *
+     * This is useful to run as an post-deploy script where you specify all the
+     * live migrations that should be run.
+     *
+     * Note: if you start multiple serial migrations, the behavior is:
+     * - If they don't overlap on functions, they will happily run in parallel.
+     * - If they have a function in common and one completes before the other
+     *   attempts it, the second will just skip it.
+     * - If they have a function in common and one is in progress, the second will
+     *   no-op and not run any further migrations in its series.
+     *
+     * To stop a migration in progress, see {@link cancelMigration}.
+     *
+     * @param ctx Context from a mutation or action. Needs `runMutation`.
+     * @param fnRefs The migrations to run in order. Like [internal.migrations.foo].
+     */
+    runSerially(ctx: MutationCtx | ActionCtx, fnRefs: MigrationFunctionReference[]): Promise<{
+        batchSize?: number;
+        cursor?: string | null;
+        error?: string;
+        isDone: boolean;
+        latestEnd?: number;
+        latestStart: number;
+        name: string;
+        next?: Array<string>;
+        processed: number;
+        state: "inProgress" | "success" | "failed" | "canceled" | "unknown";
+    } | undefined>;
+    /**
+     * Get the status of a migration or all migrations.
+     * @param ctx Context from a query, mutation or action. Needs `runQuery`.
+     * @param migrations The migrations to get the status of. Defaults to all.
+     * @param limit How many migrations to fetch, if not specified by name.
+     * @returns The status of the migrations, in the order of the input.
+     */
+    getStatus(ctx: QueryCtx | MutationCtx | ActionCtx, { migrations, limit, }: {
+        migrations?: (string | MigrationFunctionReference)[];
+        limit?: number;
+    }): Promise<MigrationStatus[]>;
+    /**
+     * Cancels a migration if it's in progress.
+     * You can resume it later by calling the migration without an explicit cursor.
+     * If the migration had "next" migrations, e.g. from {@link runSerially},
+     * they will not run. To resume, call the series again or manually pass "next".
+     * @param ctx Context from a mutation or action. Needs `runMutation`.
+     * @param migration Migration to cancel. Either the name like "migrations:foo"
+     * or the function reference like `internal.migrations.foo`.
+     * @returns The status of the migration after attempting to cancel it.
+     */
+    cancel(ctx: MutationCtx | ActionCtx, migration: MigrationFunctionReference | string): Promise<MigrationStatus>;
+    /**
+     * Cancels all migrations that are in progress.
+     * You can resume it later by calling the migration without an explicit cursor.
+     * If the migration had "next" migrations, e.g. from {@link runSerially},
+     * they will not run. To resume, call the series again or manually pass "next".
+     * @param ctx Context from a mutation or action. Needs `runMutation`.
+     * @returns The status of up to 100 of the canceled migrations.
+     */
+    cancelAll(ctx: MutationCtx | ActionCtx): Promise<{
+        batchSize?: number;
+        cursor?: string | null;
+        error?: string;
+        isDone: boolean;
+        latestEnd?: number;
+        latestStart: number;
+        name: string;
+        next?: Array<string>;
+        processed: number;
+        state: "inProgress" | "success" | "failed" | "canceled" | "unknown";
+    }[]>;
+    private prefixedName;
+}
+export type MigrationFunctionReference = FunctionReference<"mutation", "internal", MigrationArgs>;
+/**
+ * Start a migration and run it synchronously until it's done.
+ * If this function crashes, the migration will not continue.
+ *
+ * ```ts
+ * // In an action
+ * const toRun = internal.migrations.myMigration;
+ * await runToCompletion(ctx, components.migrations, toRun);
+ * ```
+ *
+ * If it's already in progress, it will no-op.
+ * If you run a migration that had previously failed which was part of a series,
+ * it will not resume the series.
+ * To resume a series, call the series again: {@link Migrations.runSerially}.
+ *
+ * Note: It's up to you to determine if it's safe to run a migration while
+ * others are in progress. It won't run multiple instances of the same migration
+ * but it currently allows running multiple migrations on the same table.
+ *
+ * @param ctx Context from an action.
+ * @param component The migrations component, usually `components.migrations`.
+ * @param fnRef The migration function to run. Like `internal.migrations.foo`.
+ * @param opts Options to start the migration.
+ *   It's helpful to see what it would do without committing the transaction.
+ */
+export declare function runToCompletion(ctx: ActionCtx, component: ComponentApi, fnRef: MigrationFunctionReference | MigrationFunctionHandle, opts?: {
+    /**
+     * The name of the migration function, generated with getFunctionName.
+     */
+    name?: string;
+    /**
+     * The cursor to start from.
+     * null: start from the beginning.
+     * undefined: start, or resume from where it failed. No-ops if already done.
+     */
+    cursor?: string | null;
+    /**
+     * The number of documents to process in a batch.
+     * Overrides the migrations's configured batch size.
+     */
+    batchSize?: number;
+    /**
+     * If true, it will run a batch and then throw an error.
+     * It's helpful to see what it would do without committing the transaction.
+     */
+    dryRun?: boolean;
+    args?: any;
+}): Promise<MigrationStatus>;
+type QueryCtx = Pick<GenericQueryCtx<GenericDataModel>, "runQuery">;
+type MutationCtx = Pick<GenericMutationCtx<GenericDataModel>, "runQuery" | "runMutation">;
+type ActionCtx = Pick<GenericActionCtx<GenericDataModel>, "runQuery" | "runMutation" | "storage">;
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"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"}