@aws-amplify/data-schema 0.15.0 → 0.16.0

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

@@ -0,0 +1,150 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+  AmplifyServer,
+  AuthModeParams,
+  BaseClient,
+  BaseBrowserClient,
+  BaseSSRClient,
+  ClientInternalsGetter,
+  GraphQLOptions,
+  GraphQLResult,
+  ListArgs,
+  ModelIntrospectionSchema,
+  SchemaModel,
+  QueryArgs,
+} from '../../bridge-types';
+
+import {
+  ModelOperation,
+  authModeParams,
+  buildGraphQLVariables,
+  flattenItems,
+  generateGraphQLDocument,
+  getCustomHeaders,
+  initializeModel,
+} from '../APIClient';
+
+export function getFactory(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  operation: ModelOperation,
+  getInternals: ClientInternalsGetter,
+  useContext = false,
+) {
+  const getWithContext = async (
+    contextSpec: AmplifyServer.ContextSpec & GraphQLOptions,
+    arg?: any,
+    options?: any,
+  ) => {
+    return _get(
+      client,
+      modelIntrospection,
+      model,
+      arg,
+      options,
+      operation,
+      getInternals,
+      contextSpec,
+    );
+  };
+
+  const get = async (arg?: any, options?: any) => {
+    return _get(
+      client,
+      modelIntrospection,
+      model,
+      arg,
+      options,
+      operation,
+      getInternals,
+    );
+  };
+
+  return useContext ? getWithContext : get;
+}
+
+async function _get(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  arg: QueryArgs,
+  options: AuthModeParams & ListArgs,
+  operation: ModelOperation,
+  getInternals: ClientInternalsGetter,
+  context?: AmplifyServer.ContextSpec,
+) {
+  const { name } = model;
+
+  const query = generateGraphQLDocument(
+    modelIntrospection,
+    name,
+    operation,
+    options,
+  );
+  const variables = buildGraphQLVariables(
+    model,
+    operation,
+    arg,
+    modelIntrospection,
+  );
+
+  try {
+    const auth = authModeParams(client, getInternals, options);
+
+    const headers = getCustomHeaders(client, getInternals, options?.headers);
+
+    const { data, extensions } = context
+      ? ((await (client as BaseSSRClient).graphql(
+          context,
+          {
+            ...auth,
+            query,
+            variables,
+          },
+          headers,
+        )) as GraphQLResult)
+      : ((await (client as BaseBrowserClient).graphql(
+          {
+            ...auth,
+            query,
+            variables,
+          },
+          headers,
+        )) as GraphQLResult);
+
+    // flatten response
+    if (data) {
+      const [key] = Object.keys(data);
+      const flattenedResult = flattenItems(data)[key];
+
+      if (options?.selectionSet) {
+        return { data: flattenedResult, extensions };
+      } else {
+        // TODO: refactor to avoid destructuring here
+        const [initialized] = initializeModel(
+          client,
+          name,
+          [flattenedResult],
+          modelIntrospection,
+          auth.authMode,
+          auth.authToken,
+          !!context,
+        );
+
+        return { data: initialized, extensions };
+      }
+    } else {
+      return { data: null, extensions };
+    }
+  } catch (error: any) {
+    if (error.errors) {
+      // graphql errors pass through
+      return error as any;
+    } else {
+      // non-graphql errors re re-thrown
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,178 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+  AmplifyServer,
+  AuthModeParams,
+  BaseClient,
+  ClientInternalsGetter,
+  GraphQLResult,
+  ListArgs,
+  ModelIntrospectionSchema,
+  SchemaModel,
+  QueryArgs,
+} from '../../bridge-types';
+
+import {
+  authModeParams,
+  buildGraphQLVariables,
+  flattenItems,
+  generateGraphQLDocument,
+  getCustomHeaders,
+  initializeModel,
+} from '../APIClient';
+
+export interface IndexMeta {
+  queryField: string;
+  pk: string;
+  sk?: string[];
+}
+
+export function indexQueryFactory(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  indexMeta: IndexMeta,
+  getInternals: ClientInternalsGetter,
+  context = false,
+) {
+  const indexQueryWithContext = async (
+    contextSpec: AmplifyServer.ContextSpec,
+    args: QueryArgs,
+    options?: ListArgs,
+  ) => {
+    return _indexQuery(
+      client,
+      modelIntrospection,
+      model,
+      indexMeta,
+      getInternals,
+      {
+        ...args,
+        ...options,
+      },
+      contextSpec,
+    );
+  };
+
+  const indexQuery = async (args: QueryArgs, options?: ListArgs) => {
+    return _indexQuery(
+      client,
+      modelIntrospection,
+      model,
+      indexMeta,
+      getInternals,
+      {
+        ...args,
+        ...options,
+      },
+    );
+  };
+
+  return context ? indexQueryWithContext : indexQuery;
+}
+
+function processGraphQlResponse(
+  result: GraphQLResult,
+  selectionSet: undefined | string[],
+  modelInitializer: (flattenedResult: any[]) => any[],
+) {
+  const { data, extensions } = result;
+
+  const [key] = Object.keys(data);
+
+  if (data[key].items) {
+    const flattenedResult = flattenItems(data)[key];
+
+    return {
+      data: selectionSet ? flattenedResult : modelInitializer(flattenedResult),
+      nextToken: data[key].nextToken,
+      extensions,
+    };
+  }
+
+  return {
+    data: data[key],
+    nextToken: data[key].nextToken,
+    extensions,
+  };
+}
+
+function handleGraphQlError(error: any) {
+  if (error.errors) {
+    // graphql errors pass through
+    return error as any;
+  } else {
+    // non-graphql errors re re-thrown
+    throw error;
+  }
+}
+
+async function _indexQuery(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  indexMeta: IndexMeta,
+  getInternals: ClientInternalsGetter,
+  args?: ListArgs & AuthModeParams,
+  contextSpec?: AmplifyServer.ContextSpec,
+) {
+  const { name } = model;
+
+  const query = generateGraphQLDocument(
+    modelIntrospection,
+    name,
+    'INDEX_QUERY',
+    args,
+    indexMeta,
+  );
+  const variables = buildGraphQLVariables(
+    model,
+    'INDEX_QUERY',
+    args,
+    modelIntrospection,
+    indexMeta,
+  );
+
+  const auth = authModeParams(client, getInternals, args);
+
+  const modelInitializer = (flattenedResult: any[]) =>
+    initializeModel(
+      client,
+      name,
+      flattenedResult,
+      modelIntrospection,
+      auth.authMode,
+      auth.authToken,
+      !!contextSpec,
+    );
+
+  try {
+    const headers = getCustomHeaders(client, getInternals, args?.headers);
+
+    const graphQlParams = {
+      ...auth,
+      query,
+      variables,
+    };
+
+    const requestArgs: [any, any] = [graphQlParams, headers];
+
+    if (contextSpec !== undefined) {
+      requestArgs.unshift(contextSpec);
+    }
+
+    const response = (await (client as BaseClient).graphql(
+      ...requestArgs,
+    )) as GraphQLResult;
+
+    if (response.data !== undefined) {
+      return processGraphQlResponse(
+        response,
+        args?.selectionSet,
+        modelInitializer,
+      );
+    }
+  } catch (error: any) {
+    return handleGraphQlError(error);
+  }
+}

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

@@ -0,0 +1,143 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+  AmplifyServer,
+  AuthModeParams,
+  BaseClient,
+  BaseBrowserClient,
+  BaseSSRClient,
+  ClientInternalsGetter,
+  GraphQLResult,
+  ListArgs,
+  ModelIntrospectionSchema,
+  SchemaModel,
+} from '../../bridge-types';
+
+import {
+  authModeParams,
+  buildGraphQLVariables,
+  flattenItems,
+  generateGraphQLDocument,
+  getCustomHeaders,
+  initializeModel,
+} from '../APIClient';
+
+export function listFactory(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  getInternals: ClientInternalsGetter,
+  context = false,
+) {
+  const listWithContext = async (
+    contextSpec: AmplifyServer.ContextSpec,
+    args?: ListArgs,
+  ) => {
+    return _list(
+      client,
+      modelIntrospection,
+      model,
+      getInternals,
+      args,
+      contextSpec,
+    );
+  };
+
+  const list = async (args?: Record<string, any>) => {
+    return _list(client, modelIntrospection, model, getInternals, args);
+  };
+
+  return context ? listWithContext : list;
+}
+
+async function _list(
+  client: BaseClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  getInternals: ClientInternalsGetter,
+  args?: ListArgs & AuthModeParams,
+  contextSpec?: AmplifyServer.ContextSpec,
+) {
+  const { name } = model;
+
+  const query = generateGraphQLDocument(modelIntrospection, name, 'LIST', args);
+  const variables = buildGraphQLVariables(
+    model,
+    'LIST',
+    args,
+    modelIntrospection,
+  );
+
+  try {
+    const auth = authModeParams(client, getInternals, args);
+
+    const headers = getCustomHeaders(client, getInternals, args?.headers);
+
+    const { data, extensions } = contextSpec
+      ? ((await (client as BaseSSRClient).graphql(
+          contextSpec,
+          {
+            ...auth,
+            query,
+            variables,
+          },
+          headers,
+        )) as GraphQLResult)
+      : ((await (client as BaseBrowserClient).graphql(
+          {
+            ...auth,
+            query,
+            variables,
+          },
+          headers,
+        )) as GraphQLResult);
+
+    // flatten response
+    if (data !== undefined) {
+      const [key] = Object.keys(data);
+
+      if (data[key].items) {
+        const flattenedResult = flattenItems(data)[key];
+
+        // don't init if custom selection set
+        if (args?.selectionSet) {
+          return {
+            data: flattenedResult,
+            nextToken: data[key].nextToken,
+            extensions,
+          };
+        } else {
+          const initialized = initializeModel(
+            client,
+            name,
+            flattenedResult,
+            modelIntrospection,
+            auth.authMode,
+            auth.authToken,
+            !!contextSpec,
+          );
+
+          return {
+            data: initialized,
+            nextToken: data[key].nextToken,
+            extensions,
+          };
+        }
+      }
+
+      return {
+        data: data[key],
+        nextToken: data[key].nextToken,
+        extensions,
+      };
+    }
+  } catch (error: any) {
+    if (error.errors) {
+      // graphql errors pass through
+      return error as any;
+    } else {
+      // non-graphql errors re re-thrown
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,146 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observable } from 'rxjs';
+import { SchemaModel } from '../../bridge-types';
+
+import { findIndexByFields, resolvePKFields } from '../../utils';
+
+export function observeQueryFactory(models: any, model: SchemaModel) {
+  const { name } = model;
+
+  const observeQuery = (arg?: any) =>
+    new Observable((subscriber) => {
+      // what we'll be sending to our subscribers
+      const items: object[] = [];
+
+      // To enqueue subscription messages while we collect our initial
+      // result set.
+      const messageQueue = [] as {
+        type: 'create' | 'update' | 'delete';
+        item: object;
+      }[];
+
+      // operation to take when message(s) arrive.
+      // this operation will be swapped out once initial "sync" is complete
+      // to immediately ingest messsages.
+      let receiveMessages = (...messages: typeof messageQueue) => {
+        return messageQueue.push(...messages);
+      };
+
+      // start subscriptions
+      const onCreateSub = models[name].onCreate(arg).subscribe({
+        next(item: object) {
+          receiveMessages({ item, type: 'create' });
+        },
+        error(error: any) {
+          subscriber.error({ type: 'onCreate', error });
+        },
+      });
+      const onUpdateSub = models[name].onUpdate(arg).subscribe({
+        next(item: object) {
+          receiveMessages({ item, type: 'update' });
+        },
+        error(error: any) {
+          subscriber.error({ type: 'onUpdate', error });
+        },
+      });
+      const onDeleteSub = models[name].onDelete(arg).subscribe({
+        next(item: object) {
+          receiveMessages({ item, type: 'delete' });
+        },
+        error(error: any) {
+          subscriber.error({ type: 'onDelete', error });
+        },
+      });
+
+      // consumes a list of messages and sends a snapshot
+      function ingestMessages(messages: typeof messageQueue) {
+        for (const message of messages) {
+          const idx = findIndexByFields(message.item, items, pkFields as any);
+          switch (message.type) {
+            case 'create':
+              if (idx < 0) items.push(message.item);
+              break;
+            case 'update':
+              if (idx >= 0) items[idx] = message.item;
+              break;
+            case 'delete':
+              if (idx >= 0) items.splice(idx, 1);
+              break;
+            default:
+              console.error('Unrecognized message in observeQuery.', message);
+          }
+        }
+        subscriber.next({
+          items,
+          isSynced: true,
+        });
+      }
+
+      const pkFields = resolvePKFields(model);
+
+      // initial results
+      (async () => {
+        let firstPage = true;
+        let nextToken: string | null = null;
+        while (!subscriber.closed && (firstPage || nextToken)) {
+          firstPage = false;
+
+          const {
+            data: page,
+            errors,
+            nextToken: _nextToken,
+          }: {
+            data: any;
+            errors: any;
+            nextToken: string | null;
+          } = await models[name].list({ ...arg, nextToken });
+          nextToken = _nextToken;
+
+          items.push(...page);
+
+          // if there are no more pages and no items we already know about
+          // that need to be merged in from sub, we're "synced"
+          const isSynced =
+            messageQueue.length === 0 &&
+            (nextToken === null || nextToken === undefined);
+
+          subscriber.next({
+            items,
+            isSynced,
+          });
+
+          if (Array.isArray(errors)) {
+            for (const error of errors) {
+              subscriber.error(error);
+            }
+          }
+        }
+
+        // play through the queue
+        if (messageQueue.length > 0) {
+          ingestMessages(messageQueue);
+        }
+
+        // switch the queue to write directly to the items collection
+        receiveMessages = (...messages: typeof messageQueue) => {
+          ingestMessages(messages);
+
+          return items.length;
+        };
+      })();
+
+      // when subscriber unsubscribes, tear down internal subs
+      return () => {
+        // 1. tear down internal subs
+        onCreateSub.unsubscribe();
+        onUpdateSub.unsubscribe();
+        onDeleteSub.unsubscribe();
+
+        // 2. there is no need to explicitly stop paging. instead, we
+        // just check `subscriber.closed` above before fetching each page.
+      };
+    });
+
+  return observeQuery;
+}

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

@@ -0,0 +1,78 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { map } from 'rxjs';
+import {
+  BaseBrowserClient,
+  ClientInternalsGetter,
+  GraphqlSubscriptionResult,
+  ModelIntrospectionSchema,
+  SchemaModel,
+} from '../../bridge-types';
+
+import {
+  ModelOperation,
+  authModeParams,
+  buildGraphQLVariables,
+  generateGraphQLDocument,
+  getCustomHeaders,
+  initializeModel,
+} from '../APIClient';
+
+export function subscriptionFactory(
+  client: BaseBrowserClient,
+  modelIntrospection: ModelIntrospectionSchema,
+  model: SchemaModel,
+  operation: ModelOperation,
+  getInternals: ClientInternalsGetter,
+) {
+  const { name } = model as any;
+
+  const subscription = (args?: Record<string, any>) => {
+    const query = generateGraphQLDocument(
+      modelIntrospection,
+      name,
+      operation,
+      args,
+    );
+
+    const variables = buildGraphQLVariables(
+      model,
+      operation,
+      args,
+      modelIntrospection,
+    );
+
+    const auth = authModeParams(client, getInternals, args);
+
+    const headers = getCustomHeaders(client, getInternals, args?.headers);
+
+    const observable = client.graphql(
+      {
+        ...auth,
+        query,
+        variables,
+      },
+      headers,
+    ) as GraphqlSubscriptionResult;
+
+    return observable.pipe(
+      map((value) => {
+        const [key] = Object.keys(value.data);
+        const data = (value.data as any)[key];
+        const [initialized] = initializeModel(
+          client,
+          name,
+          [data],
+          modelIntrospection,
+          auth.authMode,
+          auth.authToken,
+        );
+
+        return initialized;
+      }),
+    );
+  };
+
+  return subscription;
+}