@opengeni/contracts 0.36.0 → 0.37.0

package/src/connector-destinations.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+
+export const ConnectorDocumentDestinationAuthority = z.enum([
+  "organization",
+  "workspace",
+  "personal",
+]);
+export type ConnectorDocumentDestinationAuthority = z.infer<
+  typeof ConnectorDocumentDestinationAuthority
+>;
+
+export const ConnectorDocumentDestinationSelection = z.object({
+  authorityKind: ConnectorDocumentDestinationAuthority,
+  collectionId: z.string().uuid().nullable().default(null),
+});
+export type ConnectorDocumentDestinationSelection = z.infer<
+  typeof ConnectorDocumentDestinationSelection
+>;
+
+export const ConnectorDocumentDestination = z
+  .object({
+    authorityKind: ConnectorDocumentDestinationAuthority,
+    authorityAccountId: z.string().uuid(),
+    authorityWorkspaceId: z.string().uuid().nullable(),
+    authoritySubjectId: z.string().trim().min(1).max(1024).nullable(),
+    collectionId: z.string().uuid().nullable().default(null),
+  })
+  .superRefine((destination, context) => {
+    if (destination.authorityKind === "organization") {
+      if (destination.authorityWorkspaceId !== null || destination.authoritySubjectId !== null) {
+        context.addIssue({
+          code: "custom",
+          message: "organization connector destinations cannot bind workspace or subject authority",
+        });
+      }
+      return;
+    }
+    if (destination.authorityWorkspaceId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace and personal connector destinations require workspace authority",
+      });
+    }
+    if (destination.authorityKind === "workspace" && destination.authoritySubjectId !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace connector destinations cannot bind subject authority",
+      });
+    }
+    if (destination.authorityKind === "personal" && destination.authoritySubjectId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "personal connector destinations require immutable subject authority",
+      });
+    }
+  });
+export type ConnectorDocumentDestination = z.infer<typeof ConnectorDocumentDestination>;
+
+export function bindConnectorDocumentDestination(
+  selection: ConnectorDocumentDestinationSelection,
+  context: { accountId: string; workspaceId: string; initiatingSubjectId: string },
+): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: selection.authorityKind,
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: selection.authorityKind === "organization" ? null : context.workspaceId,
+    authoritySubjectId: selection.authorityKind === "personal" ? context.initiatingSubjectId : null,
+    collectionId: selection.collectionId,
+  });
+}
+
+export function legacyWorkspaceConnectorDocumentDestination(context: {
+  accountId: string;
+  workspaceId: string;
+}): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: "workspace",
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: context.workspaceId,
+    authoritySubjectId: null,
+    collectionId: null,
+  });
+}
+
+export function resolveConnectorDocumentDestination(
+  value: unknown,
+  context: {
+    accountId: string;
+    workspaceId: string;
+    connectionSubjectId?: string | null | undefined;
+  },
+): ConnectorDocumentDestination {
+  if (value === undefined || value === null) {
+    return legacyWorkspaceConnectorDocumentDestination(context);
+  }
+  const destination = ConnectorDocumentDestination.parse(value);
+  if (destination.authorityAccountId !== context.accountId) {
+    throw new Error("connector destination organization authority mismatch");
+  }
+  if (
+    destination.authorityKind !== "organization" &&
+    destination.authorityWorkspaceId !== context.workspaceId
+  ) {
+    throw new Error("connector destination workspace authority mismatch");
+  }
+  if (
+    destination.authorityKind === "personal" &&
+    destination.authoritySubjectId !== context.connectionSubjectId
+  ) {
+    throw new Error("connector destination personal authority mismatch");
+  }
+  return destination;
+}
+
+export function connectorDestinationDocumentAuthority(destination: ConnectorDocumentDestination): {
+  authorityKind: ConnectorDocumentDestinationAuthority;
+  authorityWorkspaceId: string | null;
+  authoritySubjectId: string | null;
+} {
+  return {
+    authorityKind: destination.authorityKind,
+    authorityWorkspaceId: destination.authorityWorkspaceId,
+    authoritySubjectId: destination.authoritySubjectId,
+  };
+}
+
+export function connectorDocumentDestinationCollectionId(
+  destination: ConnectorDocumentDestination,
+  defaultCollectionId: string,
+): string {
+  return destination.collectionId ?? z.string().uuid().parse(defaultCollectionId);
+}

package/src/google-drive.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 
 import { ConnectionMetadata } from "./index";
+import {
+  ConnectorDocumentDestination,
+  ConnectorDocumentDestinationSelection,
+} from "./connector-destinations";
 
 export const GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com" as const;
 export const GOOGLE_DRIVE_FULL_SCOPE = "https://www.googleapis.com/auth/drive" as const;
@@ -63,6 +67,7 @@ export function googleDriveScopesAllowCapability(
   return googleDriveOAuthScopeDecision(grantedScopes).capabilities.includes(capability);
 }
 
+/** @deprecated Connector document destinations use organization/workspace/personal authority. */
 export const GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
 export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
 
@@ -130,7 +135,9 @@ export const GoogleDriveSelectedSource = z.object({
   name: z.string().min(1).max(1024),
   mimeType: z.string().min(1).max(256),
   driveId: z.string().min(1).max(256).nullable().default(null),
-  targetScope: GoogleDriveTargetScope,
+  destination: ConnectorDocumentDestination.optional(),
+  /** @deprecated Missing destinations resolve to the current workspace boundary. */
+  targetScope: GoogleDriveTargetScope.optional(),
   syncCadence: GoogleDriveSyncCadence.default("hourly"),
   readPolicy: GoogleDriveReadPolicy.default("allow"),
   selectedAt: z.string().datetime({ offset: true }),
@@ -147,6 +154,7 @@ export const GoogleDriveConnectionMetadata = z
     verifiedAt: z.string().datetime({ offset: true }),
     accessMode: z.enum(["metadata_readonly", "readonly"]),
     lifecycle: GoogleDriveConnectionLifecycle.optional(),
+    documentDestination: ConnectorDocumentDestination.optional(),
     selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
     /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
     selectedSource: GoogleDriveSelectedSource.nullable().optional(),
@@ -199,22 +207,28 @@ export const GoogleDriveBrowseResponse = z.object({
 });
 export type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;
 
-export const SaveGoogleDriveSourceRequest = z.object({
-  sources: z
-    .array(
-      GoogleDriveBrowseItem.pick({
-        id: true,
-        name: true,
-        mimeType: true,
-        driveId: true,
+export const SaveGoogleDriveSourceRequest = z
+  .object({
+    sources: z
+      .array(
+        GoogleDriveBrowseItem.pick({
+          id: true,
+          name: true,
+          mimeType: true,
+          driveId: true,
+        }),
+      )
+      .max(100)
+      .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
+        message: "Google Drive sources must be unique",
       }),
-    )
-    .max(100)
-    .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
-      message: "Google Drive sources must be unique",
-    }),
-  targetScope: GoogleDriveTargetScope,
-  syncCadence: GoogleDriveSyncCadence.default("hourly"),
-  readPolicy: GoogleDriveReadPolicy.default("allow"),
-});
+    destination: ConnectorDocumentDestinationSelection.optional(),
+    /** @deprecated Legacy requests are accepted but resolve to workspace authority. */
+    targetScope: GoogleDriveTargetScope.optional(),
+    syncCadence: GoogleDriveSyncCadence.default("hourly"),
+    readPolicy: GoogleDriveReadPolicy.default("allow"),
+  })
+  .refine((request) => request.destination !== undefined || request.targetScope !== undefined, {
+    message: "Google Drive document destination is required",
+  });
 export type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;

package/src/index.ts

@@ -8,6 +8,7 @@ import {
 import { WorkspaceInstructionPolicyRoleKeyInput } from "./workspace-instruction-policies";
 
 export * from "./slack-bot-scopes";
+export * from "./connector-destinations";
 
 export {
   CreateWorkspaceArtifactRequest,
@@ -1149,7 +1150,11 @@ export const ClientVoiceInputConfig = z
   .object({
     available: z.boolean(),
     maxDurationSeconds: z.number().int().positive().max(600),
-    maxSizeBytes: z.number().int().positive(),
+    maxSizeBytes: z
+      .number()
+      .int()
+      .positive()
+      .max(25 * 1024 * 1024),
     acceptedMimeTypes: z.array(z.string().trim().min(1).max(128)).min(1).max(32),
   })
   .strict();
@@ -1164,7 +1169,7 @@ export const TranscribeAudioResponse = z
   .strict();
 export type TranscribeAudioResponse = z.infer<typeof TranscribeAudioResponse>;
 
-/** Default ceilings for native voice input (hard-stop recording + upload). */
+/** Default safety ceiling for one-shot native voice input (60 seconds). */
 export const VOICE_INPUT_MAX_DURATION_SECONDS = 60 as const;
 export const VOICE_INPUT_MAX_SIZE_BYTES = 25 * 1024 * 1024;
 export const VOICE_INPUT_ACCEPTED_MIME_TYPES = [