@aws-amplify/data-schema 1.4.0 → 1.5.0

package/src/runtime/internals/ai/createSendMessageFunction.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { SingularReturnValue } from '../..';
+import type {
+  Conversation,
+  ConversationMessage,
+} from '../../../ai/ConversationType';
+import type {
+  BaseClient,
+  ClientInternalsGetter,
+  ModelIntrospectionSchema,
+} from '../../bridge-types';
+import { customOpFactory } from '../operations/custom';
+import { convertItemToConversationMessage } from './convertItemToConversationMessage';
+import {
+  serializeAiContext,
+  serializeContent,
+  serializeToolConfiguration,
+} from './conversationMessageSerializers';
+
+export const createSendMessageFunction =
+  (
+    client: BaseClient,
+    modelIntrospection: ModelIntrospectionSchema,
+    conversationId: string,
+    conversationRouteName: string,
+    getInternals: ClientInternalsGetter,
+  ): Conversation['sendMessage'] =>
+  async ({ aiContext, content, toolConfiguration }) => {
+    const { conversations } = modelIntrospection;
+
+    // Safe guard for standalone function. When called as part of client generation, this should never be falsy.
+    if (!conversations) {
+      return {} as SingularReturnValue<ConversationMessage>;
+    }
+    const sendSchema = conversations[conversationRouteName].message.send;
+    const sendOperation = customOpFactory(
+      client,
+      modelIntrospection,
+      'mutation',
+      sendSchema,
+      false,
+      getInternals,
+    ) as (
+      args?: Record<string, any>,
+    ) => SingularReturnValue<ConversationMessage>;
+    const { data, errors } = await sendOperation({
+      conversationId,
+      content: serializeContent(content),
+      ...(aiContext && { aiContext: serializeAiContext(aiContext) }),
+      ...(toolConfiguration && {
+        toolConfiguration: serializeToolConfiguration(toolConfiguration),
+      }),
+    });
+    return {
+      data: data ? convertItemToConversationMessage(data) : data,
+      errors,
+    };
+  };

package/src/runtime/internals/index.ts

@@ -5,6 +5,8 @@ export {
   generateCustomQueriesProperty,
   generateCustomSubscriptionsProperty,
 } from './generateCustomOperationsProperty';
+export { generateConversationsProperty } from './utils/clientProperties/generateConversationsProperty';
+export { generateGenerationsProperty } from './utils/clientProperties/generateGenerationsProperty';
 export { generateEnumsProperty } from './utils/clientProperties/generateEnumsProperty';
 export { generateModelsProperty } from './utils/clientProperties/generateModelsProperty';
 export { isGraphQLResponseWithErrors } from './utils/runtimeTypeGuards/isGraphQLResponseWithErrors';

package/src/runtime/internals/operations/custom.ts

@@ -13,6 +13,10 @@ import {
   ListArgs,
   QueryArgs,
   ModelIntrospectionSchema,
+  CustomOperationArgument,
+  InputFieldType,
+  EnumType,
+  InputType,
 } from '../../bridge-types';
 
 import { map } from 'rxjs';
@@ -194,19 +198,27 @@ function hasStringField<Field extends string>(
   return typeof o[field] === 'string';
 }
 
+function isEnumType(type: InputFieldType): type is EnumType {
+  return type instanceof Object && 'enum' in type;
+}
+
+function isInputType(type: InputFieldType): type is InputType {
+  return type instanceof Object && 'input' in type;
+}
+
 /**
  * @param argDef A single argument definition from a custom operation
  * @returns A string naming the base type including the `!` if the arg is required.
  */
-function argumentBaseTypeString(
-  argDef: Exclude<CustomOperation['arguments'], undefined>[number],
-) {
-  const requiredFlag = argDef.isRequired ? '!' : '';
-  if (argDef.type instanceof Object && 'enum' in argDef.type) {
-    return argDef.type.enum + requiredFlag;
-  } else {
-    return argDef.type + requiredFlag;
+function argumentBaseTypeString({ type, isRequired }: CustomOperationArgument) {
+  const requiredFlag = isRequired ? '!' : '';
+  if (isEnumType(type)) {
+    return `${type.enum}${requiredFlag}`;
+  }
+  if (isInputType(type)) {
+    return `${type.input}${requiredFlag}`;
   }
+  return `${type}${requiredFlag}`;
 }
 
 /**
@@ -233,10 +245,10 @@ function outerArguments(operation: CustomOperation): string {
     return '';
   }
   const args = Object.entries(operation.arguments)
-    .map(([k, v]) => {
-      const baseType = argumentBaseTypeString(v);
-      const finalType = v.isArray
-        ? `[${baseType}]${v.isArrayNullable ? '' : '!'}`
+    .map(([k, argument]) => {
+      const baseType = argumentBaseTypeString(argument);
+      const finalType = argument.isArray
+        ? `[${baseType}]${argument.isArrayNullable ? '' : '!'}`
         : baseType;
 
       return `$${k}: ${finalType}`;

package/src/runtime/internals/utils/clientProperties/generateConversationsProperty.ts

@@ -0,0 +1,91 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { ConversationRoute } from '../../../../ai/ConversationType';
+import {
+  BaseClient,
+  ClientInternalsGetter,
+  GraphQLProviderConfig,
+  ModelIntrospectionSchema,
+} from '../../../bridge-types';
+import { createCreateConversationFunction } from '../../ai/createCreateConversationFunction';
+import { createGetConversationFunction } from '../../ai/createGetConversationFunction';
+import { createListConversationsFunction } from '../../ai/createListConversationsFunction';
+
+export function generateConversationsProperty(
+  client: BaseClient,
+  apiGraphQLConfig: GraphQLProviderConfig['GraphQL'],
+  getInternals: ClientInternalsGetter,
+): Record<string, ConversationRoute> {
+  const modelIntrospection: ModelIntrospectionSchema | undefined =
+    apiGraphQLConfig?.modelIntrospection;
+
+  // conversations will be absent from model intro schema if no conversation routes
+  // are present on the source schema.
+  if (!modelIntrospection?.conversations) {
+    return {};
+  }
+
+  const conversations: Record<string, ConversationRoute> = {};
+
+  for (const {
+    name,
+    conversation,
+    message,
+    models,
+    nonModels,
+    enums,
+  } of Object.values(modelIntrospection.conversations)) {
+    const conversationModel = models[conversation.modelName];
+    const conversationMessageModel = models[message.modelName];
+
+    if (!conversationModel || !conversationMessageModel) {
+      return {};
+    }
+
+    const conversationModelIntrospection: ModelIntrospectionSchema = {
+      ...modelIntrospection,
+      models: {
+        ...modelIntrospection.models,
+        ...models,
+      },
+      nonModels: {
+        ...modelIntrospection.nonModels,
+        ...nonModels,
+      },
+      enums: {
+        ...modelIntrospection.enums,
+        ...enums,
+      },
+    };
+
+    conversations[name] = {
+      create: createCreateConversationFunction(
+        client,
+        conversationModelIntrospection,
+        name,
+        conversationModel,
+        conversationMessageModel,
+        getInternals,
+      ),
+      get: createGetConversationFunction(
+        client,
+        conversationModelIntrospection,
+        name,
+        conversationModel,
+        conversationMessageModel,
+        getInternals,
+      ),
+      list: createListConversationsFunction(
+        client,
+        conversationModelIntrospection,
+        name,
+        conversationModel,
+        conversationMessageModel,
+        getInternals,
+      ),
+    };
+  }
+
+  return conversations;
+}

package/src/runtime/internals/utils/clientProperties/generateGenerationsProperty.ts

@@ -0,0 +1,41 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  BaseClient,
+  ClientInternalsGetter,
+  GraphQLProviderConfig,
+  ModelIntrospectionSchema,
+} from '../../../bridge-types';
+import { CustomQueries } from '../../../client';
+import { customOpFactory } from '../../operations/custom';
+
+export function generateGenerationsProperty<T extends Record<any, any>>(
+  client: BaseClient,
+  apiGraphQLConfig: GraphQLProviderConfig['GraphQL'],
+  getInternals: ClientInternalsGetter,
+): CustomQueries<T> {
+  const modelIntrospection: ModelIntrospectionSchema | undefined =
+    apiGraphQLConfig?.modelIntrospection;
+
+  // generations will be absent from model intro schema if no generation routes
+  // are present on the source schema.
+  if (!modelIntrospection?.generations) {
+    return {} as CustomQueries<T>;
+  }
+
+  const generations: Record<string, any> = {};
+
+  for (const generation of Object.values(modelIntrospection.generations)) {
+    generations[generation.name] = customOpFactory(
+      client,
+      modelIntrospection,
+      'query',
+      generation,
+      false,
+      getInternals,
+    );
+  }
+
+  return generations as CustomQueries<T>;
+}