Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

32.9 KB
Raw Blame
#[test]
fn email_senders_are_embedded_and_legacy_participants_remain_available() {
    let sdl = crate::build_schema().sdl();
    let participant = sdl
        .split_once("type GraphqlSoupEmailSender {")
        .expect("email sender type")
        .1
        .split_once('}')
        .expect("end of email sender type")
        .0;
    assert!(
        participant
            .lines()
            .any(|line| line.trim() == "contactId: ID!")
    );
    assert!(sdl.contains("senders: [GraphqlSoupEmailSender!]!"));
    assert!(sdl.contains("participants: [GraphqlSoupEmailParticipant!]!"));
    assert!(
        !participant
            .lines()
            .any(|line| line.trim().starts_with("id:")),
        "message-specific names must not be normalized by contact ID"
    );
}

#[test]
fn soup_response_schema_exposes_frontend_fields() {
    let sdl = crate::build_schema().sdl();

    for expected in [
        "type GraphqlSoupChannel implements GraphqlSoupEntity {",
        "organizationId: ID",
        "interactedAt: String",
        "isParticipant: Boolean!",
        "participantIds: [String!]!",
        "participants: [GraphqlSoupChannelParticipant!]!",
        "latestMessage: GraphqlSoupChannelMessagePreview",
        "latestNonThreadMessage: GraphqlSoupChannelMessagePreview",
        "input EmailThreadInput {",
        "threadId: ID!",
        "emailLabels: [GraphqlSoupEmailLabel!]!",
        "emailLinks: [GraphqlEmailLink!]!",
        "favorites(filter: FavoritesFilterInput): [GraphqlFavorite!]!",
        "folders: [GraphqlSoupProject!]!",
        "input FavoritesFilterInput {",
        "entityTypes: [GraphqlEntityType!]! = []",
        "entityIds: [ID!]! = []",
        "emailThread(input: EmailThreadInput!): GraphqlSoupEmailThread",
        "type GraphqlSoupEmailThread implements GraphqlSoupEntity {",
        "providerId: String",
        "inboxVisible: Boolean!",
        "linkId: ID!",
        "latestInboundMessageTs: String",
        "senderPhotoUrl: String",
        "participants: [GraphqlSoupEmailParticipant!]! @deprecated(reason: \"Use senders to preserve message-specific display names.\")",
        "senders: [GraphqlSoupEmailSender!]!",
        "attachments: [GraphqlSoupEmailAttachment!]!",
        "labels: [GraphqlSoupEmailLabel!]!",
        "type GraphqlEmailLink {",
        "sendAs: [GraphqlEmailSendAsAddress!]",
        "type GraphqlEmailSendAsAddress {",
        "displayName: String",
        "macroId: String!",
        "emailAddress: String!",
        "photoUrl: String",
        "provider: GraphqlEmailProvider!",
        "isSyncActive: Boolean!",
        "syncStatus: GraphqlEmailSyncStatus!",
        "needsReauth: Boolean!",
        "settings: GraphqlEmailLinkSettings!",
        "isPrimary: Boolean!",
        "type GraphqlEmailLinkSettings {",
        "signatureOnRepliesForwards: Boolean!",
        "signature: String",
        "properties: [GraphqlProperty!]!",
        "messages(offset: Int, limit: Int): [GraphqlSoupEmailMessage!]!",
        "latestContentMessage: GraphqlSoupEmailMessage",
        "type GraphqlSoupEmailMessage {",
        "replyingToId: ID",
        "scheduledSendTime: String",
        "isDraft: Boolean!",
        "bodyParsed: String",
        "bodyHtmlSanitized: String",
        "bodyReplyless: String",
        "attachments: [GraphqlSoupEmailMessageAttachment!]!",
        "attachmentsDraft: [GraphqlSoupEmailDraftAttachment!]!",
        "attachmentsForwarded: [GraphqlSoupEmailForwardedAttachment!]!",
        "type GraphqlSoupEmailMessageAttachment {",
        "sfsId: ID",
        "type GraphqlSoupEmailDraftAttachment {",
        "type GraphqlSoupEmailForwardedAttachment {",
        "type GraphqlSoupCall implements GraphqlSoupEntity {",
        "type GraphqlSoupAgentSession implements GraphqlSoupEntity {",
        "bot: GraphqlSessionBot",
        "type GraphqlSessionBot {",
        "avatarUrl: String",
        "channelName: String",
        "customName: String",
        "status: String!",
        "participantIds: [String!]!",
        "participants: [GraphqlSoupCallParticipant!]!",
        "type GraphqlSoupChat implements GraphqlSoupEntity {",
        "deletedAt: String",
        "type GraphqlSoupProject implements GraphqlSoupEntity {",
        "type GraphqlSoupInitiative implements GraphqlSoupEntity {",
        "initiativeFilter: GraphqlInitiativeExpr",
        "parent: GraphqlEntity",
        "type GraphqlCacheDeletion {",
        "graphqlTypeName: String!",
        "entityId: ID!",
        "type SoupUpdated {",
        "item: GraphqlSoupEntity!",
        "union SoupPatch = SoupUpdated | GraphqlCacheDeletion",
        "type GraphqlMutationSuccess {",
        "effects: [SoupPatch!]!",
        "setEntityFavorite(entity: EntityRefInput!, favorite: Boolean!): GraphqlEntityMutationResult!",
        "setFavorite(entity: EntityRefInput!, favorite: Boolean!): SetFavoritePayload!",
        "type SetFavoritePayload {",
        "result: GraphqlEntityMutationResult!",
        "favorite: GraphqlFavorite",
        "reorderFavorites(input: ReorderFavoritesInput!): [GraphqlFavorite!]!",
        "input ReorderFavoritesInput {",
        "favorites: [EntityRefInput!]!",
        "type GraphqlFavorite {",
        "entityType: GraphqlEntityType!",
        "entityId: ID!",
        "sortOrder: Float!",
        "recordChannelActivity(input: RecordChannelActivityInput!): GraphqlChannelActivity!",
        "updateNotifications(input: UpdateNotificationsInput!): [GraphqlNotification!]!",
        "updateNotificationsForEntity(input: UpdateNotificationsForEntityInput!): [GraphqlNotification!]!",
        "input UpdateNotificationsForEntityInput {",
        "entities: [NotificationEntityInput!]!",
        "input NotificationEntityInput {",
        "entityType: GraphqlEntityType!",
        "entityId: ID!",
        "markEmailThreadSeen(input: MarkEmailThreadSeenInput!): GraphqlSoupEmailThread!",
        "updateEmailThreadLabel(input: UpdateEmailThreadLabelInput!): GraphqlSoupEmailThread!",
        "saveEmailDraft(input: SaveEmailDraftInput!): SaveEmailDraftPayload!",
        "sendEmailMessage(input: SendEmailMessageInput!): SendEmailMessagePayload!",
        "input SendEmailMessageInput {",
        "sendEmailAttempt(input: SendEmailAttemptInput!): SendEmailAttemptPayload!",
        "input SendEmailAttemptInput {",
        "draft: SaveEmailDraftInput!",
        "includeSignature: Boolean",
        "type SendEmailMessagePayload {",
        "type SendEmailAttemptPayload {",
        "messageId: ID!",
        "senderEmail: String",
        "deleteEmailDraft(input: DeleteEmailDraftInput!): DeleteEmailDraftPayload!",
        "input MarkEmailThreadSeenInput {",
        "input UpdateEmailThreadLabelInput {",
        "labelId: ID!",
        "value: Boolean!",
        "input SaveEmailDraftInput {",
        "draftId: ID!",
        "input SaveEmailDraftContactInput {",
        "type SaveEmailDraftPayload {",
        "draft: GraphqlSoupEmailMessage!",
        "thread: GraphqlSoupEmailThread!",
        "input DeleteEmailDraftInput {",
        "type DeleteEmailDraftPayload {",
        "deleted: Boolean!",
        "threadDeleted: Boolean!",
        "enum ChannelActivityType {",
        "enum NotificationUpdateOperation {",
        "MARK_SEEN",
        "MARK_DONE",
        "MARK_UNDONE",
        "type CompleteSubscriptionRoot {",
        "soupUpdates: [SoupPatch!]!",
        "notificationUpdates: GraphqlNotificationPatch!",
        "union GraphqlNotificationPatch = GraphqlNewNotification | GraphqlUpdatedNotification | GraphqlCacheDeletion",
        "type GraphqlNewNotification {",
        "notification: GraphqlNotification!",
        "type GraphqlUpdatedNotification {",
        "activityUpdates: GraphqlActivityPatch!",
        "union GraphqlActivityPatch = GraphqlActivityEvent | GraphqlActivityInvalidation",
        "type GraphqlNotification {",
        "metadata: GraphqlNotifEvent!",
    ] {
        assert_sdl_line(&sdl, expected);
    }
    let schema = apollo_compiler::Schema::parse_and_validate(&sdl, "schema.graphql")
        .expect("generated SDL is valid");
    let apollo_compiler::schema::ExtendedType::Union(metadata) = schema
        .types
        .get("GraphqlNotifEvent")
        .expect("notification metadata union exists")
    else {
        panic!("notification metadata must be represented by the typed event union");
    };
    for expected in [
        "GraphqlChannelMentionMetadata",
        "GraphqlEntityAccessRequestedMetadata",
        "GraphqlEntityAccessGrantedMetadata",
        "GraphqlChannelAccessRequestedMetadata",
    ] {
        assert!(
            metadata
                .members
                .iter()
                .any(|member| member.name.as_str() == expected),
            "notification metadata union missing {expected}"
        );
    }
    assert_eq!(
        sdl.lines()
            .filter(|line| line.trim() == "metadata: GraphqlNotifEvent!")
            .count(),
        1,
        "stored and realtime notifications must share one typed metadata field"
    );
    assert!(!sdl.contains("GraphqlRealtimeNotification"));
    assert!(!sdl.contains("GraphqlSoupNotification"));
    assert!(
        !sdl.lines()
            .any(|line| line.trim() == "type GraphqlEntityRef {"),
        "Soup metadata must reuse the canonical GraphqlEntity object"
    );
    assert_eq!(
        sdl.matches("type GraphqlSoupEmailLabel {").count(),
        1,
        "thread labels and the user catalog must share one normalized typename"
    );
    assert!(
        !sdl.to_ascii_lowercase().contains("fusionauth"),
        "internal FusionAuth identifiers must not enter the GraphQL contract"
    );
}

#[test]
fn activity_overview_is_a_user_scoped_embedded_value() {
    use apollo_compiler::schema::ExtendedType;

    let schema =
        apollo_compiler::Schema::parse_and_validate(crate::build_schema().sdl(), "schema.graphql")
            .expect("generated SDL is valid");
    let ExtendedType::Object(user) = schema.types.get("GraphqlUser").expect("user type exists")
    else {
        panic!("GraphqlUser must be an object");
    };
    assert!(user.fields.contains_key("activityOverview"));

    for name in [
        "GraphqlActivityOverview",
        "GraphqlActivityDay",
        "GraphqlActivityEntityRank",
    ] {
        let ExtendedType::Object(value) =
            schema.types.get(name).expect("overview value type exists")
        else {
            panic!("{name} must be an object");
        };
        assert!(
            !value.fields.contains_key("id"),
            "{name} must remain embedded under GraphqlUser"
        );
    }
}

#[test]
fn soup_interface_exposes_the_complete_shared_entity_contract() {
    use apollo_compiler::schema::ExtendedType;

    let schema =
        apollo_compiler::Schema::parse_and_validate(crate::build_schema().sdl(), "schema.graphql")
            .expect("generated SDL is valid");
    let ExtendedType::Interface(entity) = schema
        .types
        .get("GraphqlSoupEntity")
        .expect("Soup entity interface exists")
    else {
        panic!("GraphqlSoupEntity must be an interface");
    };

    for shared_field in [
        "id",
        "entityType",
        "displayName",
        "metadata",
        "properties",
        "notifications",
        "isFavorited",
        "viewerPermission",
        "frecencyScore",
        "cacheProjection",
        "activity",
    ] {
        assert!(
            entity.fields.contains_key(shared_field),
            "Soup interface missing shared field {shared_field}"
        );
    }
    let cache_projection = entity
        .fields
        .get("cacheProjection")
        .expect("Soup interface cache projection field exists");
    assert!(
        cache_projection.arguments.is_empty(),
        "cacheProjection must remain argument-free"
    );
    assert_eq!(cache_projection.ty.to_string(), "SoupCacheProjection");

    assert!(
        !schema.types.contains_key("GraphqlSoupItem"),
        "soup items are entities directly; no query-scoped wrapper type"
    );
    assert!(
        !entity.fields.contains_key("content"),
        "entity-specific content must not be flattened into the shared Soup interface"
    );

    let ExtendedType::Object(document) = schema
        .types
        .get("GraphqlSoupDocument")
        .expect("Soup document type exists")
    else {
        panic!("GraphqlSoupDocument must be an object");
    };
    for shared_field in [
        "isFavorited",
        "viewerPermission",
        "properties",
        "notifications",
        "cacheProjection",
        "activity",
    ] {
        assert!(
            document.fields.contains_key(shared_field),
            "Soup document missing shared field {shared_field}"
        );
    }
    assert!(
        !document.fields.contains_key("isEmailAttachment"),
        "relation-backed projection facts must not become document business fields"
    );

    for name in [
        "GraphqlSoupCalendarEvent",
        "GraphqlSoupDocument",
        "GraphqlSoupChat",
        "GraphqlSoupProject",
        "GraphqlSoupInitiative",
        "GraphqlSoupEmailThread",
        "GraphqlSoupChannel",
        "GraphqlSoupChannelMessage",
        "GraphqlSoupCall",
        "GraphqlSoupCrmCompany",
        "GraphqlSoupForeignEntity",
        "GraphqlSoupAgentSession",
        "GraphqlSoupDatabaseRow",
        "GraphqlSoupReminder",
    ] {
        let ExtendedType::Object(object) = schema.types.get(name).expect("Soup object exists")
        else {
            panic!("{name} must be an object");
        };
        assert!(
            object.fields.contains_key("cacheProjection"),
            "{name} must implement the shared cacheProjection field"
        );
    }

    for name in ["SoupPage", "SoupUpdated"] {
        let ExtendedType::Object(object) = schema.types.get(name).expect("Soup wrapper exists")
        else {
            panic!("{name} must be an object");
        };
        assert!(
            !object.fields.contains_key("cacheProjection"),
            "{name} must not carry entity projection metadata"
        );
        if name == "SoupUpdated" {
            assert_eq!(object.fields["item"].ty.to_string(), "GraphqlSoupEntity!");
        }
    }
}

#[test]
fn schema_types_and_fields_have_descriptions() {
    use apollo_compiler::schema::ExtendedType;

    let schema =
        apollo_compiler::Schema::parse_and_validate(crate::build_schema().sdl(), "schema.graphql")
            .expect("generated SDL is valid");

    let mut missing = Vec::new();
    for (name, graphql_type) in &schema.types {
        if graphql_type.is_built_in() {
            continue;
        }
        if graphql_type.description().is_none() {
            missing.push(format!("type {name}"));
        }

        match graphql_type {
            ExtendedType::Object(ty) => collect_undocumented(
                &mut missing,
                name,
                ty.fields
                    .iter()
                    .map(|(name, field)| (name, field.description.is_none())),
            ),
            ExtendedType::Interface(ty) => collect_undocumented(
                &mut missing,
                name,
                ty.fields
                    .iter()
                    .map(|(name, field)| (name, field.description.is_none())),
            ),
            ExtendedType::InputObject(ty) => collect_undocumented(
                &mut missing,
                name,
                ty.fields
                    .iter()
                    .map(|(name, field)| (name, field.description.is_none())),
            ),
            ExtendedType::Enum(ty) => collect_undocumented(
                &mut missing,
                name,
                ty.values
                    .iter()
                    .map(|(name, value)| (name, value.description.is_none())),
            ),
            ExtendedType::Scalar(_) | ExtendedType::Union(_) => {}
        }
    }

    assert!(
        missing.is_empty(),
        "GraphQL schema items missing descriptions: {}",
        missing.join(", ")
    );
}

fn collect_undocumented<'a>(
    missing: &mut Vec<String>,
    type_name: &str,
    items: impl Iterator<Item = (&'a apollo_compiler::Name, bool)>,
) {
    for (name, is_undocumented) in items {
        if is_undocumented {
            missing.push(format!("{type_name}.{name}"));
        }
    }
}

#[test]
fn property_values_are_a_typed_union_without_soup_names() {
    let sdl = crate::build_schema().sdl();

    assert_sdl_line(
        &sdl,
        "union GraphqlPropertyValue = GraphqlBooleanPropertyValue | GraphqlNumberPropertyValue | GraphqlStringPropertyValue | GraphqlDatePropertyValue | GraphqlDateRangePropertyValue | GraphqlSelectOptionPropertyValue | GraphqlEntityReferencePropertyValue | GraphqlLinkPropertyValue",
    );
    assert!(!sdl.contains("GraphqlSoupProperty"));
    assert!(!sdl.contains("GraphqlSoupDataType"));
}

#[test]
fn initiative_reads_and_mutations_share_the_canonical_soup_entity() {
    let sdl = crate::build_schema().sdl();
    let object = |name: &str| {
        let declaration = format!("type {name}");
        sdl.split_once(&declaration)
            .expect("GraphQL object exists")
            .1
            .split_once('{')
            .unwrap()
            .1
            .split_once("\n}")
            .unwrap()
            .0
    };
    assert_sdl_line(
        object("GraphqlUser"),
        "initiative(initiativeId: ID!): GraphqlSoupInitiative!",
    );
    assert!(!object("SoupQueryRoot").contains("initiative"));
    for field in [
        "id: ID!",
        "properties: [GraphqlProperty!]!",
        "memberIds: [String!]!",
        "taskIds: [ID!]!",
        "sharePermission: InitiativeSharePermission!",
        "taskCount: Int!",
        "completedTaskCount: Int!",
    ] {
        assert_sdl_line(object("GraphqlSoupInitiative"), field);
    }
    assert_sdl_line(
        &sdl,
        "createInitiative(input: CreateInitiativeInput!): GraphqlSoupInitiative!",
    );
    assert_sdl_line(
        &sdl,
        "ensureInitiativeDescriptionSurface(initiativeId: ID!): ID!",
    );
    assert_sdl_line(
        &sdl,
        "ensureInitiativeDescriptionSurface(initiativeId: ID!): ID!",
    );
    assert_sdl_line(
        &sdl,
        "updateInitiative(initiativeId: ID!, input: UpdateInitiativeInput!): GraphqlSoupInitiative!",
    );
    for obsolete in [
        "type GraphqlInitiative {",
        "type InitiativePage {",
        "input InitiativePageInput {",
        "enum InitiativeSort {",
        "type InitiativePropertySnapshot {",
        "initiatives(input:",
        // Tasks join a project through their Project property.
        "type TaskInitiativeReference {",
        "taskInitiativeReferences(",
        "assignInitiativeTasks(",
        "unassignInitiativeTask(",
        "clearTaskInitiative(",
    ] {
        assert!(!sdl.contains(obsolete), "obsolete API remains: {obsolete}");
    }
    for duplicate in [
        "name:",
        "ownerId:",
        "createdAt:",
        "updatedAt:",
        "userAccessLevel:",
        "propertySnapshot:",
    ] {
        assert!(
            !object("GraphqlSoupInitiative").contains(duplicate),
            "duplicate initiative field remains: {duplicate}"
        );
    }
}

#[test]
fn database_rows_are_an_opt_in_soup_entity_named_by_table() {
    let sdl = crate::build_schema().sdl();
    let block = |declaration: &str| {
        sdl.split_once(declaration)
            .unwrap_or_else(|| panic!("schema has no `{declaration}`"))
            .1
            .split_once("\n}")
            .unwrap()
            .0
            .to_owned()
    };
    let row = block("type GraphqlSoupDatabaseRow implements GraphqlSoupEntity {");
    for field in [
        "id: ID!",
        "entityType: GraphqlSoupEntityType!",
        "tableId: ID!",
        "databaseId: ID!",
        "position: String!",
        "ownerId: String!",
        "creatorId: String",
        "createdAt: String!",
        "updatedAt: String!",
        "properties: [GraphqlProperty!]!",
    ] {
        assert_sdl_line(&row, field);
    }
    assert_sdl_line(
        &block("input GraphqlEntityFilterAst {"),
        "databaseRowFilter: GraphqlDatabaseRowExpr",
    );
    let literal = block("input GraphqlDatabaseRowLiteral @oneOf {");
    assert_sdl_line(&literal, "tableId: ID");
    assert_sdl_line(&literal, "id: ID");
    assert_sdl_line(&block("enum GraphqlSoupEntityType {"), "DATABASE_ROW");
}

#[test]
fn crm_records_carry_their_pipeline_entries() {
    let sdl = crate::build_schema().sdl();
    let block = |declaration: &str| {
        sdl.split_once(declaration)
            .unwrap_or_else(|| panic!("schema has no `{declaration}`"))
            .1
            .split_once("\n}")
            .unwrap()
            .0
            .to_owned()
    };
    for record in [
        "type GraphqlSoupCrmCompany implements GraphqlSoupEntity {",
        "type GraphqlSoupCrmContact implements GraphqlSoupEntity {",
    ] {
        assert_sdl_line(
            &block(record),
            "pipelineEntries: [GraphqlCrmPipelineEntry!]!",
        );
    }
    let entry = block("type GraphqlCrmPipelineEntry {");
    for field in [
        "id: ID!",
        "pipeline: GraphqlCrmPipeline!",
        "cells: [GraphqlCrmPipelineCell!]!",
    ] {
        assert_sdl_line(&entry, field);
    }
    // A cell is a fact about its row, so it stays embedded in the entry.
    let cell = block("type GraphqlCrmPipelineCell {");
    assert!(!cell.lines().any(|line| line.trim() == "id: ID!"));
    assert_sdl_line(&cell, "column: GraphqlCrmPipelineColumn!");
    assert_sdl_line(&cell, "value: GraphqlPropertyValue");
    let column = block("type GraphqlCrmPipelineColumn {");
    assert_sdl_line(&column, "id: ID!");
    assert_sdl_line(&column, "writable: Boolean!");
    assert_sdl_line(&column, "options: [GraphqlPropertyOption!]!");
    let pipeline = block("type GraphqlCrmPipeline {");
    assert_sdl_line(&pipeline, "id: ID!");
    assert_sdl_line(&pipeline, "canEdit: Boolean!");
}

#[test]
fn crm_associations_scope_soup_and_compose_in_document_trees() {
    let sdl = crate::build_schema().sdl();
    let block = |declaration: &str| {
        sdl.split_once(declaration)
            .unwrap_or_else(|| panic!("schema has no `{declaration}`"))
            .1
            .split_once("\n}")
            .unwrap()
            .0
            .to_owned()
    };
    assert_sdl_line(
        &block("input GraphqlEntityFilterAst {"),
        "crmAssociation: GraphqlCrmAssociation",
    );
    let document = block("input GraphqlDocumentLiteral @oneOf {");
    assert_sdl_line(&document, "crmAssociated: GraphqlCrmAssociation");
    assert_sdl_line(&document, "nameContains: String");
    let association = block("input GraphqlCrmAssociation @oneOf {");
    assert_sdl_line(&association, "company: ID");
    assert_sdl_line(&association, "contact: ID");
}

#[test]
fn scheduled_actions_hang_off_the_authenticated_user() {
    use apollo_compiler::schema::ExtendedType;

    let sdl = crate::build_schema().sdl();
    assert_sdl_line(&sdl, "scheduledActions: [GraphqlScheduledAction!]!");
    assert_sdl_line(
        &sdl,
        "union GraphqlScheduledActionTrigger = GraphqlScheduledActionCronTrigger | GraphqlScheduledActionEventsTrigger | GraphqlScheduledActionOnceTrigger | GraphqlScheduledActionMultipleTrigger",
    );
    assert!(sdl.contains("AI routines the authenticated user can access."));
    for value in [
        "DOCUMENT_CREATED",
        "DOCUMENT_UPDATED",
        "DOCUMENT_DELETED",
        "TASK_CREATED",
        "TASK_STATUS_CHANGED",
        "TASK_PRIORITY_CHANGED",
        "TASK_PROPERTY_CHANGED",
        "EMAIL_MESSAGE_RECEIVED",
        "CHANNEL_CREATED",
        "CHANNEL_MESSAGE_POSTED",
        "CHANNEL_MENTIONED",
        "CHANNEL_MESSAGE_PATCHED",
        "CHANNEL_MESSAGE_ATTACHMENT_CREATED",
        "CALL_STARTED",
        "CALL_ENDED",
    ] {
        assert_sdl_line(&sdl, value);
    }

    let schema = apollo_compiler::Schema::parse_and_validate(sdl.as_str(), "schema.graphql")
        .expect("generated SDL is valid");
    let ExtendedType::Object(user) = schema.types.get("GraphqlUser").expect("user type") else {
        panic!("GraphqlUser must be an object");
    };
    assert!(user.fields.contains_key("scheduledActions"));
    assert!(
        user.fields["scheduledActions"]
            .description
            .as_ref()
            .expect("scheduledActions documentation")
            .to_string()
            .contains("authenticated user")
    );

    let ExtendedType::Object(root) = schema.types.get("SoupQueryRoot").expect("query root") else {
        panic!("SoupQueryRoot must be an object");
    };
    assert!(!root.fields.contains_key("scheduledActions"));

    let ExtendedType::Interface(soup) = schema
        .types
        .get("GraphqlSoupEntity")
        .expect("soup entity interface")
    else {
        panic!("GraphqlSoupEntity must be an interface");
    };
    assert!(!soup.fields.contains_key("scheduledActions"));

    let ExtendedType::Enum(soup_types) = schema
        .types
        .get("GraphqlSoupEntityType")
        .expect("soup entity type enum")
    else {
        panic!("GraphqlSoupEntityType must be an enum");
    };
    assert!(!soup_types.values.contains_key("SCHEDULED_ACTION"));
    let ExtendedType::Enum(entity_types) = schema
        .types
        .get("GraphqlEntityType")
        .expect("entity type enum")
    else {
        panic!("GraphqlEntityType must be an enum");
    };
    assert!(entity_types.values.contains_key("SCHEDULED_ACTION"));

    let ExtendedType::Object(action) = schema
        .types
        .get("GraphqlScheduledAction")
        .expect("routine object")
    else {
        panic!("GraphqlScheduledAction must be an object");
    };
    assert_eq!(action.fields["id"].ty.to_string(), "ID!");
    assert_eq!(
        action
            .fields
            .keys()
            .map(|name| name.to_string())
            .collect::<Vec<_>>(),
        vec![
            "id",
            "name",
            "enabled",
            "trigger",
            "agentTask",
            "claimExpiresAt",
            "createdAt",
            "updatedAt",
        ]
    );
    for absent in [
        "owner",
        "kind",
        "task",
        "configurationRevision",
        "eventActivatedAt",
        "isRunning",
        "nextRunAt",
    ] {
        assert!(
            !action.fields.contains_key(absent),
            "{absent} must stay off the routine object"
        );
    }
    assert!(
        action.fields["claimExpiresAt"]
            .description
            .as_ref()
            .expect("claimExpiresAt documentation")
            .to_string()
            .contains("after that instant")
    );

    let ExtendedType::Object(cron) = schema
        .types
        .get("GraphqlScheduledActionCronTrigger")
        .expect("cron trigger")
    else {
        panic!("cron trigger must be an object");
    };
    assert!(!cron.fields.contains_key("id"));
    assert_eq!(cron.fields["nextRunAt"].ty.to_string(), "String");
    assert!(
        cron.fields["nextRunAt"]
            .description
            .as_ref()
            .expect("nextRunAt documentation")
            .to_string()
            .contains("disabled")
    );

    let ExtendedType::Object(task) = schema
        .types
        .get("GraphqlScheduledActionAgentTask")
        .expect("agent task")
    else {
        panic!("agent task must be an object");
    };
    assert_eq!(task.fields["model"].ty.to_string(), "String");
    assert_eq!(
        task.fields["agent"].ty.to_string(),
        "GraphqlScheduledActionAgent"
    );

    for embedded in [
        "GraphqlScheduledActionEventsTrigger",
        "GraphqlScheduledActionEventFilter",
        "GraphqlScheduledActionAgentTask",
        "GraphqlScheduledActionAgent",
    ] {
        let ExtendedType::Object(value) = schema.types.get(embedded).expect(embedded) else {
            panic!("{embedded} must be an object");
        };
        assert!(
            !value.fields.contains_key("id"),
            "{embedded} must stay embedded"
        );
    }

    let ExtendedType::Object(agent) = schema
        .types
        .get("GraphqlScheduledActionAgent")
        .expect("scheduled action agent")
    else {
        panic!("scheduled action agent must be an object");
    };
    assert_eq!(agent.fields["botId"].ty.to_string(), "ID!");

    let ExtendedType::Object(filter) = schema
        .types
        .get("GraphqlScheduledActionEventFilter")
        .expect("event filter")
    else {
        panic!("event filter must be an object");
    };
    assert_eq!(filter.fields["entityIds"].ty.to_string(), "[ID!]");
    let entity_ids = filter.fields["entityIds"]
        .description
        .as_ref()
        .expect("entityIds documentation")
        .to_string();
    assert!(entity_ids.contains("Null matches every id"), "{entity_ids}");
    assert!(
        entity_ids.contains("empty list matches nothing"),
        "{entity_ids}"
    );
}

#[test]
fn calendar_reads_hang_off_the_authenticated_user() {
    use apollo_compiler::schema::ExtendedType;

    let sdl = crate::build_schema().sdl();
    for expected in [
        "calendars: [GraphqlCalendar!]!",
        "calendarOccurrences(input: CalendarRangeInput!): GraphqlCalendarOccurrencePage!",
        "union GraphqlEventTime = GraphqlTimedEventTime | GraphqlAllDayEventTime",
        "watermark: [GraphqlCalendarLinkWatermark!]!",
        "calendarChanges(input: CalendarChangesInput!): GraphqlCalendarChanges!",
        "since: [CalendarLinkWatermarkInput!]!",
        "newWatermark: [GraphqlCalendarLinkWatermark!]!",
        "occurrences: [GraphqlCalendarOccurrence!]!",
        "createCalendarEvent(input: CreateCalendarEventInput!): GraphqlCalendarMutationPayload!",
        "updateCalendarEvent(input: UpdateCalendarEventInput!): GraphqlCalendarMutationPayload!",
        "deleteCalendarEvent(input: DeleteCalendarEventInput!): GraphqlCalendarMutationPayload!",
        "respondToCalendarEvent(input: RespondToCalendarEventInput!): GraphqlCalendarMutationPayload!",
        "input CalendarEventTimeInput @oneOf {",
        "deletedEventId: ID",
        "needsCalendarPermission: Boolean!",
        "calendarDisabled: Boolean!",
        "hasCalendarData: Boolean!",
    ] {
        assert_sdl_line(&sdl, expected);
    }

    let schema = apollo_compiler::Schema::parse_and_validate(sdl.as_str(), "schema.graphql")
        .expect("generated SDL is valid");
    let ExtendedType::Object(occurrence) = schema
        .types
        .get("GraphqlCalendarOccurrence")
        .expect("occurrence type")
    else {
        panic!("GraphqlCalendarOccurrence must be an object");
    };
    for scalar in ["id", "eventId", "linkId"] {
        assert_eq!(occurrence.fields[scalar].ty.to_string(), "ID!");
    }
    assert_eq!(
        occurrence.fields["event"].ty.to_string(),
        "GraphqlCalendarEvent!"
    );
    for entity in ["GraphqlCalendarEvent", "GraphqlCalendar"] {
        let ExtendedType::Object(object) = schema.types.get(entity).expect("entity type") else {
            panic!("{entity} must be an object");
        };
        assert_eq!(object.fields["id"].ty.to_string(), "ID!");
        assert_eq!(object.fields["linkId"].ty.to_string(), "ID!");
    }

    let ExtendedType::Object(root) = schema.types.get("SoupQueryRoot").expect("query root") else {
        panic!("SoupQueryRoot must be an object");
    };
    assert!(!root.fields.contains_key("calendars"));
    assert!(!root.fields.contains_key("calendarOccurrences"));
    assert!(!root.fields.contains_key("calendarChanges"));
}

/// The exported SDL is a frontend contract: `schema.graphql` feeds the client
/// codegen and the normalized-cache metadata. Splitting the schema across
/// crates must never change it silently — regenerate with
/// `cargo run -p complete_graph --bin graphql_schema -- static_assets/schema.graphql`.
#[test]
fn sdl_matches_committed_schema_graphql() {
    let sdl = crate::build_schema().sdl();
    assert_eq!(
        format!("{sdl}\n"),
        include_str!("../../../static_assets/schema.graphql"),
        "generated SDL diverges from the committed schema.graphql"
    );
}

fn assert_sdl_line(sdl: &str, expected: &str) {
    assert!(
        sdl.lines().any(|line| line.trim() == expected),
        "schema missing exact line `{expected}`"
    );
}

#[test]
fn saved_view_contract_is_composed_under_authenticated_user_and_mutations() {
    let sdl = crate::build_schema().sdl();
    let user = sdl
        .split_once("type GraphqlUser {")
        .expect("user type")
        .1
        .split_once('}')
        .unwrap()
        .0;
    assert!(
        user.contains("savedViews(kind: String, first: Int, after: String): GraphqlSavedViewPage!")
    );
    assert!(user.contains("savedView(id: ID!): GraphqlSavedView"));
    for field in [
        "createSavedView(input: CreateSavedViewInput!): GraphqlSavedView!",
        "updateSavedView(input: UpdateSavedViewInput!): GraphqlSavedView!",
        "deleteSavedView(input: DeleteSavedViewInput!): ID!",
        "expectedRevision: Int!",
        "sharing: SavedViewSharingInput",
        "sharedTeamId: ID",
        "nextCursor: String",
    ] {
        assert!(sdl.contains(field), "missing {field}");
    }
    let output = sdl
        .split_once("type GraphqlSavedView {")
        .unwrap()
        .1
        .split_once('}')
        .unwrap()
        .0;
    assert!(
        !output.contains("membership"),
        "membership tokens are internal"
    );
}