@superblocksteam/shared 0.9614.3 → 0.9615.1

package/src/database-lifecycle/appDatabaseImport.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  isAppDatabaseImportCallbackResult,
+  isAppDatabaseImportDispatchPayload,
+  parseAppDatabaseImportValidationMetadata
+} from './appDatabaseImport.js';
+import type { AppDatabaseImportCallback } from './index.js';
+
+describe('App Database import contracts', () => {
+  test('validates operation-specific dispatch fields', () => {
+    const base = {
+      applicationId: 'application-id',
+      bindingId: 'binding-id',
+      bindingKey: 'binding-key',
+      desiredSpec: { engine: 'postgres', logicalName: 'Orders DB' },
+      desiredSpecHash: 'desired-spec-hash',
+      import: {
+        importId: 'import-id',
+        kind: 'pg_dump_custom',
+        prefixSizeBytes: 1_024,
+        profileToken: 'profile-token',
+        resourceToken: 'resource-token'
+      },
+      organizationId: 'organization-id',
+      profile: 'production',
+      requestId: 'request-id',
+      resourceKey: 'organization/application/database/profile/default'
+    };
+
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: { ...base.import, expectedSizeBytes: 10_000 },
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(true);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: base.import,
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(false);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: {
+          ...base.import,
+          expectedSizeBytes: 10_000,
+          prefixObjectKey: 'imports/import-id/prefix'
+        },
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(false);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: { ...base.import, prefixObjectKey: 'imports/import-id/prefix' },
+        operation: 'inspect_import_prefix'
+      })
+    ).toBe(true);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: {
+          ...base.import,
+          expectedSizeBytes: 10_000,
+          prefixObjectKey: 'imports/import-id/prefix'
+        },
+        operation: 'inspect_import_prefix'
+      })
+    ).toBe(false);
+    expect({
+      ...base,
+      import: { ...base.import, expectedSizeBytes: 10_000 },
+      operation: 'prepare_import_prefix_upload'
+    }).not.toHaveProperty('import.prefixObjectKey');
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        operation: 'inspect_import_prefix'
+      })
+    ).toBe(false);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: { ...base.import, profileToken: '' },
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(false);
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...base,
+        import: { ...base.import, resourceToken: '' },
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(false);
+    const withoutOrganization: Record<string, unknown> = { ...base };
+    delete withoutOrganization.organizationId;
+    expect(
+      isAppDatabaseImportDispatchPayload({
+        ...withoutOrganization,
+        import: { ...base.import, expectedSizeBytes: 10_000 },
+        operation: 'prepare_import_prefix_upload'
+      })
+    ).toBe(false);
+  });
+
+  test('requires prefix growth and narrow nested callback results', () => {
+    expect(
+      isAppDatabaseImportCallbackResult({
+        inspectedPrefixSizeBytes: 1_024,
+        nextPrefixSizeBytes: 2_048,
+        result: 'prefix_incomplete'
+      })
+    ).toBe(true);
+    expect(
+      isAppDatabaseImportCallbackResult({
+        inspectedPrefixSizeBytes: 1_024,
+        nextPrefixSizeBytes: 1_024,
+        result: 'prefix_incomplete'
+      })
+    ).toBe(false);
+    expect(
+      isAppDatabaseImportCallbackResult({
+        prefixObjectKey: 'imports/import-id/prefix',
+        prefixUploadUrl: 'https://uploads.example/prefix',
+        result: 'prefix_upload_url'
+      })
+    ).toBe(true);
+    expect(
+      isAppDatabaseImportCallbackResult({
+        prefixUploadUrl: 'https://uploads.example/prefix',
+        result: 'prefix_upload_url'
+      })
+    ).toBe(false);
+
+    const callback: AppDatabaseImportCallback = {
+      bindingKey: 'binding-key',
+      import: {
+        prefixObjectKey: 'imports/import-id/prefix',
+        prefixUploadUrl: 'https://uploads.example/prefix',
+        result: 'prefix_upload_url'
+      },
+      lifecycleState: 'ready',
+      requestId: 'request-id'
+    };
+    if (callback.import.result !== 'prefix_upload_url') {
+      throw new Error('Expected prefix upload URL callback');
+    }
+    expect(callback.import.prefixUploadUrl).toContain('https://');
+    expect(
+      isAppDatabaseImportCallbackResult({
+        result: 'schema_validated',
+        validationMetadata: {
+          postgresMajorVersion: 16,
+          tableNames: ['public.orders']
+        }
+      })
+    ).toBe(true);
+    expect(
+      isAppDatabaseImportCallbackResult({
+        postgresMajorVersion: 16,
+        result: 'schema_validated',
+        tableNames: ['public.orders']
+      })
+    ).toBe(false);
+  });
+
+  test('retains only allowlisted validation metadata', () => {
+    expect(
+      parseAppDatabaseImportValidationMetadata({
+        postgresMajorVersion: 16,
+        rows: [{ secret: 'value' }],
+        sql: 'CREATE TABLE private_data',
+        tableNames: ['public.orders', 'public.customers']
+      })
+    ).toEqual({
+      postgresMajorVersion: 16,
+      tableNames: ['public.orders', 'public.customers']
+    });
+    expect(parseAppDatabaseImportValidationMetadata({ postgresMajorVersion: 16, tableNames: [''] })).toBeUndefined();
+  });
+});

package/src/database-lifecycle/appDatabaseImport.ts

@@ -0,0 +1,205 @@
+import type { DataImportKind, DataImportState } from './dataImport.js';
+
+export const APP_DATABASE_IMPORT_OPERATIONS = ['prepare_import_prefix_upload', 'inspect_import_prefix'] as const;
+// Subset of DATA_IMPORT_STATES. Prefix success is schema_validated, not ready.
+export const APP_DATABASE_IMPORT_STATES = [
+  'requested',
+  'preparing_prefix_upload',
+  'awaiting_prefix_upload',
+  'validating_schema',
+  'schema_validated',
+  'failed',
+  'cancelled'
+] as const satisfies readonly DataImportState[];
+export const APP_DATABASE_IMPORT_ERROR_CODES = [
+  'prefix_incomplete',
+  'schema_mismatch',
+  'unsupported_archive_format',
+  'archive_corrupt',
+  'postgres_version_newer_than_target',
+  'unsupported_object',
+  'schema_not_aligned',
+  'missing_bucket_access',
+  'internal',
+  'invalid_input',
+  'size_mismatch'
+] as const;
+
+export type AppDatabaseImportKind = Extract<DataImportKind, 'pg_dump_custom'>;
+export type AppDatabaseImportLifecycleOperation = (typeof APP_DATABASE_IMPORT_OPERATIONS)[number];
+export type AppDatabaseImportState = (typeof APP_DATABASE_IMPORT_STATES)[number];
+export type AppDatabaseImportErrorCode = (typeof APP_DATABASE_IMPORT_ERROR_CODES)[number];
+
+export type AppDatabaseImportValidationMetadata = {
+  postgresMajorVersion: number;
+  tableNames: string[];
+};
+
+export type AppDatabaseImportDispatchDetails = {
+  importId: string;
+  kind: AppDatabaseImportKind;
+  prefixSizeBytes: number;
+  profileToken: string;
+  resourceToken: string;
+};
+
+type AppDatabaseImportDispatchBase<TDesiredSpec> = {
+  applicationId: string;
+  bindingId: string;
+  bindingKey: string;
+  connectionMetadata?: Record<string, string | number | boolean>;
+  continuation?: never;
+  desiredSpec: TDesiredSpec;
+  desiredSpecHash: string;
+  environment?: never;
+  metadata?: never;
+  migrations?: never;
+  organizationId: string;
+  profile: string;
+  provisioningId?: never;
+  requestId: string;
+  resourceKey: string;
+};
+
+export type PrepareImportPrefixUploadDispatchPayloadEnvelope<TDesiredSpec> = AppDatabaseImportDispatchBase<TDesiredSpec> & {
+  import: AppDatabaseImportDispatchDetails & {
+    expectedSizeBytes: number;
+  };
+  operation: 'prepare_import_prefix_upload';
+};
+
+export type InspectImportPrefixDispatchPayloadEnvelope<TDesiredSpec> = AppDatabaseImportDispatchBase<TDesiredSpec> & {
+  import: AppDatabaseImportDispatchDetails & {
+    prefixObjectKey: string;
+  };
+  operation: 'inspect_import_prefix';
+};
+
+export type AppDatabaseImportDispatchPayloadEnvelope<TDesiredSpec> =
+  | InspectImportPrefixDispatchPayloadEnvelope<TDesiredSpec>
+  | PrepareImportPrefixUploadDispatchPayloadEnvelope<TDesiredSpec>;
+
+export type PrepareImportPrefixUploadCallbackResult = {
+  prefixObjectKey: string;
+  prefixUploadHeaders?: Record<string, string>;
+  prefixUploadUrl: string;
+  result: 'prefix_upload_url';
+};
+
+export type InspectImportPrefixCallbackResult =
+  | {
+      inspectedPrefixSizeBytes: number;
+      nextPrefixSizeBytes: number;
+      result: 'prefix_incomplete';
+    }
+  | {
+      result: 'schema_validated';
+      validationMetadata: AppDatabaseImportValidationMetadata;
+    };
+
+export type AppDatabaseImportCallbackResult = InspectImportPrefixCallbackResult | PrepareImportPrefixUploadCallbackResult;
+
+const importOperations = new Set<string>(APP_DATABASE_IMPORT_OPERATIONS);
+
+export function isAppDatabaseImportLifecycleOperation(value: string): value is AppDatabaseImportLifecycleOperation {
+  return importOperations.has(value);
+}
+
+export function isAppDatabaseImportDispatchPayload(
+  value: unknown
+): value is AppDatabaseImportDispatchPayloadEnvelope<Record<string, unknown>> {
+  if (!isUnknownRecord(value) || !hasImportDispatchBase(value)) {
+    return false;
+  }
+  if (!isNonEmptyString(value.import.profileToken) || !isNonEmptyString(value.import.resourceToken)) {
+    return false;
+  }
+  if (value.operation === 'prepare_import_prefix_upload') {
+    return value.import.prefixObjectKey === undefined && isPositiveInteger(value.import.expectedSizeBytes);
+  }
+  return (
+    value.operation === 'inspect_import_prefix' &&
+    value.import.expectedSizeBytes === undefined &&
+    isNonEmptyString(value.import.prefixObjectKey)
+  );
+}
+
+export function isAppDatabaseImportCallbackResult(value: unknown): value is AppDatabaseImportCallbackResult {
+  if (!isUnknownRecord(value)) {
+    return false;
+  }
+  if (value.result === 'prefix_upload_url') {
+    return (
+      isNonEmptyString(value.prefixObjectKey) && isNonEmptyString(value.prefixUploadUrl) && isOptionalStringMap(value.prefixUploadHeaders)
+    );
+  }
+  if (value.result === 'prefix_incomplete') {
+    return (
+      isPositiveInteger(value.inspectedPrefixSizeBytes) &&
+      isPositiveInteger(value.nextPrefixSizeBytes) &&
+      value.nextPrefixSizeBytes > value.inspectedPrefixSizeBytes
+    );
+  }
+  return value.result === 'schema_validated' && parseAppDatabaseImportValidationMetadata(value.validationMetadata) !== undefined;
+}
+
+// Rebuild metadata from its allowlisted fields so archive contents, SQL, rows,
+// and other worker-provided details cannot cross this contract boundary.
+export function parseAppDatabaseImportValidationMetadata(value: unknown): AppDatabaseImportValidationMetadata | undefined {
+  if (
+    !isUnknownRecord(value) ||
+    !isPositiveInteger(value.postgresMajorVersion) ||
+    !Array.isArray(value.tableNames) ||
+    !value.tableNames.every(isNonEmptyString)
+  ) {
+    return undefined;
+  }
+  return {
+    postgresMajorVersion: value.postgresMajorVersion,
+    tableNames: [...value.tableNames]
+  };
+}
+
+type ImportDispatchRecord = Record<string, unknown> & {
+  import: Record<string, unknown>;
+};
+
+function hasImportDispatchBase(value: Record<string, unknown>): value is ImportDispatchRecord {
+  return (
+    isNonEmptyString(value.applicationId) &&
+    isNonEmptyString(value.bindingId) &&
+    isNonEmptyString(value.bindingKey) &&
+    isUnknownRecord(value.desiredSpec) &&
+    isNonEmptyString(value.desiredSpecHash) &&
+    isUnknownRecord(value.import) &&
+    isNonEmptyString(value.import.importId) &&
+    value.import.kind === 'pg_dump_custom' &&
+    isPositiveInteger(value.import.prefixSizeBytes) &&
+    isNonEmptyString(value.organizationId) &&
+    isNonEmptyString(value.profile) &&
+    isNonEmptyString(value.requestId) &&
+    isNonEmptyString(value.resourceKey)
+  );
+}
+
+function isOptionalStringMap(value: unknown): value is Record<string, string> | undefined {
+  if (value === undefined) {
+    return true;
+  }
+  if (!isUnknownRecord(value)) {
+    return false;
+  }
+  return Object.entries(value).every(([key, entry]) => key.length > 0 && typeof entry === 'string' && entry.length > 0);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function isPositiveInteger(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/src/database-lifecycle/appDatabaseStatus.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+
+import { ViewMode } from '../types/event/index.js';
+import { isProductionDatabaseRetirementEligible, type AppDatabaseStatus, type AppDatabaseStatusBinding } from './appDatabaseStatus.js';
+
+const binding: AppDatabaseStatusBinding = {
+  bindingId: 'binding-1',
+  created: '2026-09-14T00:00:00.000Z',
+  instance: null,
+  integration: null,
+  lastActivity: '2026-09-14T00:00:00.000Z',
+  lifecycleState: 'ready',
+  logicalName: 'app_db',
+  migrationDirectory: null,
+  migrationState: 'migrated'
+};
+
+function status(overrides: Partial<AppDatabaseStatus> = {}): AppDatabaseStatus {
+  return {
+    applicationId: 'app-1',
+    hasAppDatabase: false,
+    hasDatabaseCode: false,
+    liveVersionHasAppDatabase: false,
+    tags: [
+      {
+        availableModes: [ViewMode.DEPLOYED],
+        binding,
+        deleted: false,
+        displayName: 'Production',
+        isDefaultEditor: false,
+        profileKey: 'production'
+      }
+    ],
+    ...overrides
+  };
+}
+
+describe('production database retirement eligibility', () => {
+  it('offers deletion after a live version that does not need a database and Edit leftovers are gone', () => {
+    expect(isProductionDatabaseRetirementEligible(status())).toBe(true);
+  });
+
+  it('refuses deletion while the live version still needs a database', () => {
+    expect(isProductionDatabaseRetirementEligible(status({ liveVersionHasAppDatabase: true }))).toBe(false);
+  });
+
+  it('refuses deletion while an Edit-only database remains', () => {
+    expect(
+      isProductionDatabaseRetirementEligible(
+        status({
+          tags: [
+            ...status().tags,
+            {
+              availableModes: [ViewMode.EDITOR],
+              binding: { ...binding, bindingId: 'edit-binding' },
+              deleted: false,
+              displayName: 'Staging',
+              isDefaultEditor: true,
+              profileKey: 'staging'
+            }
+          ]
+        })
+      )
+    ).toBe(false);
+  });
+
+  it('offers deletion of an unassigned leftover after a live version that does not need a database', () => {
+    expect(
+      isProductionDatabaseRetirementEligible(
+        status({
+          tags: [
+            {
+              availableModes: [],
+              binding,
+              deleted: false,
+              displayName: 'Removed production',
+              isDefaultEditor: false,
+              profileKey: 'removed-production'
+            }
+          ]
+        })
+      )
+    ).toBe(true);
+  });
+
+  it('refuses deletion while the editor default is still live, even when that tag is also deploy-allowed', () => {
+    expect(
+      isProductionDatabaseRetirementEligible(
+        status({
+          tags: [
+            ...status().tags,
+            {
+              availableModes: [ViewMode.EDITOR, ViewMode.DEPLOYED],
+              binding: { ...binding, bindingId: 'edit-binding' },
+              deleted: false,
+              displayName: 'Staging',
+              isDefaultEditor: true,
+              profileKey: 'staging'
+            }
+          ]
+        })
+      )
+    ).toBe(false);
+  });
+});

package/src/database-lifecycle/appDatabaseStatus.ts

@@ -0,0 +1,95 @@
+import { ViewMode } from '../types/event/index.js';
+import type { AppDatabaseTagRef } from './appDatabaseCompatibility.js';
+import type { DatabaseEngine, LifecycleMigrationState, LifecycleState } from './index.js';
+
+/**
+ * Builder-safe physical instance fields. Pool capacity and the internal
+ * instance id stay off this payload: they are org-wide admin facts, and
+ * capacity.used counts every application in the org.
+ */
+export type AppDatabaseStatusInstance = {
+  engine: DatabaseEngine;
+  engineVersion: string | null;
+  region: string;
+};
+
+export type AppDatabaseStatusIntegration = {
+  apiNames: string[];
+  id: string;
+  name: string;
+  pluginId: string;
+};
+
+export type AppDatabaseStatusBinding = {
+  bindingId: string;
+  created: string;
+  instance: AppDatabaseStatusInstance | null;
+  integration: AppDatabaseStatusIntegration | null;
+  lastActivity: string;
+  lifecycleState: LifecycleState;
+  logicalName: string;
+  migrationDirectory: string | null;
+  migrationState: LifecycleMigrationState;
+};
+
+export type AppDatabaseStatusTag = AppDatabaseTagRef & {
+  /** Null when this data tag has no live (non-cancelled) database. */
+  binding: AppDatabaseStatusBinding | null;
+  /**
+   * True when this data tag had a database that was retired. The live
+   * binding is omitted so the tag can be provisioned again, but Status
+   * still shows Deleted instead of No database.
+   */
+  deleted: boolean;
+  displayName: string;
+  isDefaultEditor: boolean;
+};
+
+export type AppDatabaseStatus = {
+  applicationId: string;
+  /**
+   * Whether the app declares an App Database right now (working-state
+   * requirement). Same meaning as AppDatabaseCompatibility.hasAppDatabase.
+   * A leftover live binding with no requirement still appears under tags.
+   */
+  hasAppDatabase: boolean;
+  /**
+   * Whether leftover App Database code is still in the working tree: SQL
+   * in the last known migration folder, or APIs still wired to the app's
+   * Postgres integration. Used to offer Clark cleanup after Edit databases
+   * are gone. Not a complete scan of every page or helper.
+   */
+  hasDatabaseCode: boolean;
+  /**
+   * Whether the currently live published version stamped a database
+   * requirement. Working-state (Edit) rows are not this signal: a leftover
+   * production database stays undeletable until a version without databases
+   * is live.
+   */
+  liveVersionHasAppDatabase: boolean;
+  tags: AppDatabaseStatusTag[];
+};
+
+/**
+ * Edit lifecycle membership: tags used for edit provisioning and migrations.
+ * That is every editor-only tag, plus the editor default even when that
+ * default is also deploy-allowed.
+ */
+export function isEditLifecycleTag(tag: Pick<AppDatabaseStatusTag, 'availableModes'>): boolean {
+  return tag.availableModes.includes(ViewMode.EDITOR);
+}
+
+/**
+ * Deploy lifecycle membership for builder-facing grouping: deploy-allowed
+ * tags that are not the editor default. Publish still may write the editor
+ * default when it is also deploy-allowed; that tag stays an Edit database.
+ */
+export function isDeployLifecycleTag(tag: Pick<AppDatabaseStatusTag, 'availableModes'>): boolean {
+  return tag.availableModes.includes(ViewMode.DEPLOYED) && !tag.availableModes.includes(ViewMode.EDITOR);
+}
+
+export function isProductionDatabaseRetirementEligible(status: AppDatabaseStatus): boolean {
+  const hasEditDatabase = status.tags.some((tag) => tag.binding !== null && isEditLifecycleTag(tag));
+  const hasLeftoverProductionDatabase = status.tags.some((tag) => tag.binding !== null && !isEditLifecycleTag(tag));
+  return !hasEditDatabase && hasLeftoverProductionDatabase && !status.liveVersionHasAppDatabase;
+}

package/src/database-lifecycle/dataImport.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  mintDataImportConcurrencyKey,
+  parseDataImportMetadata,
+  parseDataImportTarget,
+  type DataImportUploadMetadata
+} from './dataImport.js';
+
+describe('data import contracts', () => {
+  test('validates destination descriptors without fixing the record to one destination schema', () => {
+    expect(
+      parseDataImportTarget({
+        applicationId: 'application-id',
+        bindingId: 'binding-id',
+        profile: 'production',
+        type: 'app_database'
+      })
+    ).toEqual({
+      applicationId: 'application-id',
+      bindingId: 'binding-id',
+      profile: 'production',
+      type: 'app_database'
+    });
+    expect(parseDataImportTarget({ applicationId: 'application-id', type: 'app_database' })).toBeUndefined();
+    expect(parseDataImportTarget({ resourceId: 'resource-id', type: 'unknown' })).toBeUndefined();
+  });
+
+  test('keeps signed URLs and part ETags out of durable upload metadata', () => {
+    const metadata: DataImportUploadMetadata = {
+      completedPartNumbers: [1, 2],
+      filename: 'data.csv',
+      objectKey: 'imports/profile/resource/import/data.csv',
+      partCount: 2,
+      partSizeBytes: 16 * 1024 * 1024,
+      uploadId: 'upload-id'
+    };
+    expect(metadata.completedPartNumbers).toEqual([1, 2]);
+
+    // @ts-expect-error Signed URLs are callback-only.
+    const withSignedUrl: DataImportUploadMetadata = { filename: 'data.csv', uploadUrl: 'https://uploads.example/object' };
+    // @ts-expect-error Part ETags are sent for completion, not persisted.
+    const withEtags: DataImportUploadMetadata = { eTags: ['etag'], filename: 'data.csv' };
+    expect(withSignedUrl).toBeDefined();
+    expect(withEtags).toBeDefined();
+  });
+
+  test('stores one csv table spelling so equivalent names share an active key', () => {
+    const target = {
+      applicationId: 'application-id',
+      bindingId: 'binding-id',
+      profile: 'production',
+      type: 'app_database' as const
+    };
+    const spaced = parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: ' public.orders ' });
+    const plain = parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: 'public.orders' });
+
+    expect(spaced).toEqual({ kind: 'csv', mode: 'append', table: 'public.orders' });
+    expect(plain).toEqual(spaced);
+    if (!spaced || !plain) {
+      throw new Error('expected both table spellings to parse');
+    }
+    expect(mintDataImportConcurrencyKey(spaced, target)).toBe(`csv:${target.bindingId}:public.orders`);
+    expect(mintDataImportConcurrencyKey(plain, target)).toBe(mintDataImportConcurrencyKey(spaced, target));
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: '   ' })).toBeUndefined();
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: 'public. order items' })).toBeUndefined();
+    for (const table of ['PUBLIC.ORDERS', 'public."orders"', '"public"."orders"', 'orders']) {
+      expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table })).toBeUndefined();
+    }
+    const sixtyThree = 'a'.repeat(63);
+    const sixtyFour = 'a'.repeat(64);
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: `public.${sixtyThree}` })).toEqual({
+      kind: 'csv',
+      mode: 'append',
+      table: `public.${sixtyThree}`
+    });
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: `public.${sixtyFour}` })).toBeUndefined();
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: `${sixtyFour}.orders` })).toBeUndefined();
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: `public.${sixtyThree}x` })).toBeUndefined();
+    expect(parseDataImportMetadata('csv', { kind: 'csv', mode: 'append', table: `public.${sixtyThree}y` })).toBeUndefined();
+  });
+
+  test('rejects zero prefix sizes and a zero postgres major', () => {
+    const base = { kind: 'pg_dump_custom' as const };
+    expect(parseDataImportMetadata('pg_dump_custom', { ...base, currentPrefixSizeBytes: 0 })).toBeUndefined();
+    expect(parseDataImportMetadata('pg_dump_custom', { ...base, requestedPrefixSizeBytes: 0 })).toBeUndefined();
+    expect(parseDataImportMetadata('pg_dump_custom', { ...base, postgresMajorVersion: 0 })).toBeUndefined();
+    expect(parseDataImportMetadata('pg_dump_custom', { ...base, postgresMajorVersion: -1 })).toBeUndefined();
+    expect(parseDataImportMetadata('pg_dump_custom', { ...base, currentPrefixSizeBytes: 1, postgresMajorVersion: 16 })).toEqual({
+      kind: 'pg_dump_custom',
+      currentPrefixSizeBytes: 1,
+      postgresMajorVersion: 16
+    });
+  });
+});