@samebase/convex-hosting 0.3.1 → 0.4.0

package/dist/component/lib.d.ts

@@ -1,164 +1,183 @@
-export declare const getCurrentDeployment: import("convex/server").RegisteredQuery<"public", {}, Promise<{
-    pendingBlobCleanupCount: number | undefined;
-    _id: import("convex/values").GenericId<"deploymentInfo">;
-    _creationTime: number;
-    spaFallback?: boolean | undefined;
-    currentDeploymentId: string;
-    deployedAt: number;
-} | null>>;
-export declare const resolveAssetForHttp: import("convex/server").RegisteredQuery<"public", {
-    spaFallback?: boolean | undefined;
-    path: string;
-}, Promise<{
-    etag?: string | undefined;
-    contentType: string;
-    blobId?: string | undefined;
-    appStorageId?: import("convex/values").GenericId<"_storage"> | undefined;
-    storageUrl?: string | undefined;
-} | null>>;
-export declare const getUrls: import("convex/server").RegisteredQuery<"internal", {}, Promise<{
-    siteUrl: string;
-    cloudUrl: string;
-}>>;
-export declare const getByPath: import("convex/server").RegisteredQuery<"internal", {
-    path: string;
-}, Promise<{
-    _id: import("convex/values").GenericId<"staticAssets">;
-    _creationTime: number;
-    storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-    blobId?: string | undefined;
-    path: string;
-    deploymentId: string;
-    contentType: string;
-} | null>>;
-export declare const resolveAsset: import("convex/server").RegisteredQuery<"internal", {
-    path: string;
-}, Promise<{
-    storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-    blobId?: string | undefined;
-    path: string;
-    deploymentId: string;
-    _id: import("convex/values").GenericId<"staticAssets">;
-    _creationTime: number;
-    contentType: string;
-} | {
-    path: string;
-    deploymentId: string;
-    storageId: string & {
-        __tableName: "_storage";
-    };
-    blobId?: string | undefined;
-    _creationTime: number;
-    contentType: string;
-    _id: import("convex/values").GenericId<"retiredAssets">;
-    expiresAt: number;
-} | null>>;
-export declare const listAssets: import("convex/server").RegisteredQuery<"internal", {
-    limit?: number | undefined;
-}, Promise<{
-    _id: import("convex/values").GenericId<"staticAssets">;
-    _creationTime: number;
-    storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-    blobId?: string | undefined;
-    path: string;
-    deploymentId: string;
-    contentType: string;
-}[]>>;
-export declare const generateUploadUrl: import("convex/server").RegisteredMutation<"internal", {}, Promise<string>>;
+import { z } from "zod";
+import type { Id } from "./_generated/dataModel.js";
+/**
+ * The file that `upload` stores and `createVersion` reads: Cloudflare's `AssetConfig` for the
+ * version, without the fields that are package code.
+ */
+declare const configSchema: z.ZodObject<{
+    redirects: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        staticRules: z.ZodRecord<z.ZodString, z.ZodObject<{
+            status: z.ZodNumber;
+            to: z.ZodString;
+            lineNumber: z.ZodNumber;
+        }, z.core.$strip>>;
+        rules: z.ZodRecord<z.ZodString, z.ZodObject<{
+            status: z.ZodNumber;
+            to: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    headers: z.ZodOptional<z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        rules: z.ZodRecord<z.ZodString, z.ZodObject<{
+            set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    html_handling: z.ZodOptional<z.ZodEnum<{
+        "auto-trailing-slash": "auto-trailing-slash";
+        "force-trailing-slash": "force-trailing-slash";
+        "drop-trailing-slash": "drop-trailing-slash";
+        none: "none";
+    }>>;
+    not_found_handling: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        "single-page-application": "single-page-application";
+        "404-page": "404-page";
+    }>>;
+}, z.core.$strip>;
+export type Config = z.input<typeof configSchema>;
 export declare const generateUploadUrls: import("convex/server").RegisteredMutation<"internal", {
     count: number;
 }, Promise<string[]>>;
-export declare const listPendingBlobCleanup: import("convex/server").RegisteredQuery<"internal", {
-    limit?: number | undefined;
-}, Promise<string[]>>;
-export declare const acknowledgeBlobCleanup: import("convex/server").RegisteredMutation<"internal", {
-    blobIds: string[];
-}, Promise<{
-    acknowledged: number;
-}>>;
-export declare const queueBlobCleanup: import("convex/server").RegisteredMutation<"internal", {
-    blobIds: string[];
-}, Promise<{
-    queued: number;
-}>>;
-export declare const cleanupPendingStorage: import("convex/server").RegisteredMutation<"internal", {
-    limit?: number | undefined;
-}, Promise<{
-    processed: number;
-    deleted: number;
-    needsAnotherPass: boolean;
-}>>;
-export declare const deleteUploadedFiles: import("convex/server").RegisteredMutation<"internal", {
-    storageIds: import("convex/values").GenericId<"_storage">[];
-}, Promise<{
-    deleted: number;
-    alreadyMissing: number;
-    stillReferenced: number;
-}>>;
-export declare const stageAssets: import("convex/server").RegisteredMutation<"internal", {
-    assets: {
-        storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-        blobId?: string | undefined;
-        path: string;
-        deploymentId: string;
-        contentType: string;
-    }[];
-}, Promise<{
-    staged: number;
-}>>;
-export declare const discardStagedDeployment: import("convex/server").RegisteredMutation<"internal", {
-    deploymentId: string;
-}, Promise<{
-    discarded: number;
-}>>;
-export declare const cleanupAbandonedStaging: import("convex/server").RegisteredMutation<"internal", {
-    limit?: number | undefined;
-    before?: number | undefined;
+/**
+ * Starts a version: reads its config from storage and creates the version in state `uploading`.
+ * Idempotent for the same id and config.
+ */
+export declare const createVersion: import("convex/server").RegisteredAction<"internal", {
+    versionId: string;
+    configId: import("convex/values").GenericId<"_storage">;
+}, Promise<null>>;
+/** The write of `createVersion`: creates the version, unless it exists with the same config. */
+export declare const insertVersion: import("convex/server").RegisteredMutation<"internal", {
+    versionId: string;
+    config: string;
+}, Promise<null>>;
+/**
+ * The stored file of each hash that an entry of any version already has, in the order of
+ * `sha256s`.
+ *
+ * Each hash reads one index range (`by_sha256`) of at most one document. The CLI sends at most
+ * 8,000 characters of arguments, which hold at most 119 hashes of 67 characters: 119 index ranges
+ * of 4,096 and 119 documents read of 32,000.
+ */
+export declare const knownFiles: import("convex/server").RegisteredQuery<"internal", {
+    sha256s: string[];
 }, Promise<{
-    discarded: number;
-    deletedFiles: number;
-    queuedBlobIds: number;
-}>>;
-export declare const cleanupUnreferencedStorage: import("convex/server").RegisteredMutation<"internal", {
-    limit?: number | undefined;
-    order?: "asc" | "desc" | undefined;
-    before?: number | undefined;
-}, Promise<{
-    scanned: number;
-    deleted: number;
-    needsAnotherPass: boolean;
-}>>;
-export declare const recordAsset: import("convex/server").RegisteredMutation<"internal", {
-    storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-    blobId?: string | undefined;
-    path: string;
-    deploymentId: string;
-    contentType: string;
-}, Promise<string | null>>;
-export declare const recordAssets: import("convex/server").RegisteredMutation<"internal", {
-    assets: {
-        storageId?: import("convex/values").GenericId<"_storage"> | undefined;
-        blobId?: string | undefined;
+    sha256: string;
+    storageId: Id<"_storage">;
+}[]>>;
+/**
+ * Inserts complete entries into an `uploading` version, after checking that each stored file has
+ * the entry's sha256. An entry that exists with the same sha256 is skipped, so a retried batch
+ * passes; one that exists with another sha256 is refused.
+ *
+ * Each entry reads one index range (`by_version_path`) of at most one document and one `_storage`
+ * document, and writes at most one document. The CLI sends at most 8,000 characters of arguments,
+ * and an entry takes at least 135 of them (its sha256 and storage id alone are 96), so a call has
+ * at most 60 entries: 60 index ranges of 4,096, at most 121 documents read of 32,000 with the
+ * version, and 60 writes of 16,000.
+ */
+export declare const recordFiles: import("convex/server").RegisteredMutation<"internal", {
+    entries: {
+        contentType?: string | undefined;
         path: string;
-        deploymentId: string;
-        contentType: string;
+        sha256: string;
+        storageId: import("convex/values").GenericId<"_storage">;
     }[];
+    versionId: string;
+}, Promise<null>>;
+/**
+ * Marks an `uploading` version `ready`. The CLI calls it after every `recordFiles` batch succeeded.
+ * A version that is already `ready` or `live` stays as it is.
+ */
+export declare const finishVersion: import("convex/server").RegisteredMutation<"internal", {
+    versionId: string;
+}, Promise<null>>;
+/**
+ * Marks a `ready` version `live` and schedules `collect`. `serveAsset` calls it at the first
+ * request that the version's pushed code serves, with the `at` of the newest live version that
+ * `route` saw for that request. A mark succeeds only when the state it was based on is still the
+ * state: when the newest live version changed between the request's lookup and this mark, it does
+ * nothing, so a request whose code was replaced between its lookup and its mark cannot make its
+ * version newest. A version that is already live stays as it is, so concurrent first requests are
+ * fine.
+ */
+export declare const markLive: import("convex/server").RegisteredMutation<"public", {
+    versionId: string;
+    expectedNewestLiveAt: number | null;
+}, Promise<null>>;
+/**
+ * One chain of calls, one batch per call, each scheduling the next with `runAfter(0)` while work
+ * remains. First the `_storage` files that no entry references and that are older than
+ * `GARBAGE_AGE_MS`; then the versions, a page of `VERSION_PAGE` at a time in creation order: the
+ * live versions older than the current live one, whose code is gone because the current one has
+ * served since, and the versions that are not live and older than `GARBAGE_AGE_MS`, with their
+ * entries.
+ *
+ * A stored file is deleted when no entry references it, it is a day old, and it was already
+ * unreferenced when the chain started: the files that this chain's version deletion frees wait for
+ * a later chain, at a later switch. An upload in progress may have taken a stored file from
+ * `knownFiles` and not recorded its entry yet; it therefore fails only if two switches happen
+ * during that one upload, and a retry works.
+ *
+ * Both steps walk `by_creation_time` with a cursor: the creation time of the last document handled
+ * and the ids already handled at that time. Convex gives every document of one transaction the
+ * same creation time, and creation times are not unique across transactions either, so a cursor of
+ * a time alone would skip the other documents at the boundary. The next call reads from that time
+ * on and skips the ids in `seen`, which hold the documents of one time, normally one; it reads
+ * that many more documents, so a page still holds a full batch of new ones when they exist, and it
+ * keeps at most a batch, because a seen document may be gone.
+ */
+export declare const collect: import("convex/server").RegisteredMutation<"internal", {
+    step: {
+        after?: {
+            at: number;
+            seen: import("convex/values").GenericId<"_storage">[];
+        } | undefined;
+        kind: "files";
+    } | {
+        after?: {
+            at: number;
+            seen: import("convex/values").GenericId<"versions">[];
+        } | undefined;
+        kind: "versions";
+    };
+}, Promise<null>>;
+/**
+ * Runs Cloudflare's asset handler for one request against one version. `state` is the kind of the
+ * version's state, or `null` when the version does not exist. `newestLiveAt` is, for a `ready`
+ * version, the `at` of the newest live version that this query saw, which `serveAsset` passes to
+ * `markLive`; otherwise `null`, and a live version's requests read nothing more. `asset` is
+ * `null` when the version is uploading, being deleted, or does not exist, or when no asset answers.
+ */
+export declare const route: import("convex/server").RegisteredQuery<"public", {
+    headers: Record<string, string>;
+    url: string;
+    method: string;
+    versionId: string;
 }, Promise<{
-    blobIds: string[];
-}>>;
-export declare const publishDeployment: import("convex/server").RegisteredMutation<"internal", {
-    spaFallback?: boolean | undefined;
-    currentDeploymentId: string;
-    expectedAssetCount: number;
-}, Promise<{
-    deleted: number;
-    pendingBlobCleanup: number;
-}>>;
-export declare const commitDeployment: import("convex/server").RegisteredMutation<"internal", {
-    spaFallback?: boolean | undefined;
-    currentDeploymentId: string;
-}, Promise<{
-    deleted: number;
-    blobIds: string[];
+    state: null;
+    newestLiveAt: null;
+    asset: null;
+} | {
+    state: "uploading" | "deleting";
+    newestLiveAt: null;
+    asset: null;
+} | {
+    state: "ready" | "live";
+    newestLiveAt: number | null;
+    asset: null;
+} | {
+    state: "ready" | "live";
+    newestLiveAt: number | null;
+    asset: {
+        status: number;
+        headers: {
+            name: string;
+            value: string;
+        }[];
+        bodyUrl: string | null;
+    };
 }>>;
-//# sourceMappingURL=lib.d.ts.map
+export {};