@takeshape/schema 7.194.0

package/es/mocks.js

@@ -0,0 +1,47 @@
+import { emptySchema, applyDefaultsToSchema } from './schema-util';
+import { upperCamel } from '@takeshape/util';
+/**
+ * Like emptySchema, but setting a default `dataKey`. Only suitable for tests.
+ */
+
+export function createMockSchema(projectId, schema = {}) {
+  var _schema$dataKey;
+
+  return { ...emptySchema(projectId, (_schema$dataKey = schema.dataKey) !== null && _schema$dataKey !== void 0 ? _schema$dataKey : 'supersecret'),
+    ...schema
+  };
+}
+/**
+ * Capturing a common pattern used in tests. Creates an empty schema, with a `dataKey` and defaults.
+ */
+
+export function createMockSchemaWithDefaults(projectId, schema = {}) {
+  var _schema$dataKey2;
+
+  return applyDefaultsToSchema({ ...emptySchema(projectId, (_schema$dataKey2 = schema.dataKey) !== null && _schema$dataKey2 !== void 0 ? _schema$dataKey2 : 'supersecret'),
+    ...schema
+  });
+}
+export function createMockServiceConfig(serviceKey, serviceConfig) {
+  return {
+    id: serviceKey,
+    title: upperCamel(serviceKey),
+    provider: 'generic',
+    serviceType: 'graphql',
+    namespace: upperCamel(serviceKey),
+    authenticationType: 'bearer',
+    authentication: {
+      token: 'abc123'
+    },
+    options: {
+      endpoint: 'https://example.test/graphql'
+    },
+    ...serviceConfig
+  };
+}
+export function createMockStoredServiceConfig(serviceKey, serviceConfig) {
+  return { ...createMockServiceConfig(serviceKey),
+    authentication: 'encrypted-abc123',
+    ...serviceConfig
+  };
+}

package/es/project-schema/index.js

@@ -0,0 +1,10 @@
+// This file is generated by "pnpm json2ts"
+export * from './v3.6.0';
+export * from './v3.5.1';
+export * from './v3.5.0';
+export * from './v3.4.0';
+export * from './v3.3.0';
+export * from './v3.2.0';
+export * from './v3.1.0';
+export * from './v3.0.0';
+export * from './v1.0.0';

package/es/refs.js

@@ -0,0 +1,301 @@
+import { getRefType, isAllOfSchema, isOneOfSchema, isRefSchema, isRefSchemaLegacy } from './types';
+import { parseTemplateShape } from './template-shapes';
+import get from 'lodash/get';
+import assign from 'lodash/fp/assign';
+import omit from 'lodash/fp/omit';
+import { getServiceNamespace, getServiceNamespaces } from './services';
+
+function $refToPath(ref) {
+  return ref.substr(2).split('/');
+}
+
+function $refToShapeName(ref) {
+  return $refToPath(ref)[1];
+}
+
+export function $refToAtRef($ref, service, namespace) {
+  const shapeName = $refToShapeName($ref);
+
+  if (service === 'local') {
+    return `local:${shapeName}`;
+  }
+
+  return `${service}:${namespace === undefined ? shapeName : shapeName.replace(`${namespace}_`, '')}`;
+}
+export function refSchemaToPath(context, refSchema) {
+  const refItem = getRef(context, refSchema);
+
+  if (refItem === undefined) {
+    throw new Error('Invalid ref in refSchemaToPath');
+  }
+
+  return refItemToShapePath(refItem);
+}
+/**
+ * Safely turn a "template" shape reference (`@args`, `args`, `shape`) into a `RefItem`
+ *
+ * @param context A partial project schema
+ * @param refExpression
+ * A ref expression might include "template" name and refer to a local or remote
+ * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.*
+ */
+
+export function refExpressionToRefItem(context, refExpression) {
+  const {
+    shapeName,
+    template
+  } = parseTemplateShape(refExpression);
+
+  if (shapeName.includes(':')) {
+    return atRefToRefItem(context, shapeName, template);
+  }
+
+  return refToRefItem(context, `#/shapes/${shapeName}/schema`, template);
+}
+/**
+ * Sugar for converting a `refExpression` directly into a shape, without the
+ * intermediate `refItem`.
+ *
+ * @param context A partial project schema
+ * @param refExpression
+ * A ref expression might include "template" name and refer to a local or remote
+ * shape, `Foo` or `CreateArgs<Foo>` or `CreateArgs<remote:Foo>`.
+ */
+
+export function refExpressionToShape(context, refExpression) {
+  return refItemToShape(context, refExpressionToRefItem(context, refExpression));
+}
+/**
+ * Provided a service name and a referenced type. Supports 2 or 3 part
+ * references, e.g., `shopify:my-store:ProductInput` or `my-store:ProductInput`.
+ *
+ * @returns
+ * A 2 member array, where 0 is the service name, 1 is the referenced type.
+ */
+
+export function splitAtRef(atRef) {
+  const refParts = atRef.split(':');
+  const serviceKey = refParts.length === 2 ? refParts[0] : `${refParts[0]}:${refParts[1]}`;
+  const referencedType = refParts.length === 2 ? refParts[1] : refParts[2];
+  return [serviceKey, referencedType];
+}
+/**
+ * Parses and returns a typeName, serviceKey, and potentially a namespace for
+ * the type.
+ */
+
+export function atRefToRefItem(context, atRef, template) {
+  var _context$services;
+
+  const [serviceKey, typeName] = splitAtRef(atRef); // It's possible the service doesn't have a namespace, or is local and has
+  // no service config.
+
+  const serviceConfig = (_context$services = context.services) === null || _context$services === void 0 ? void 0 : _context$services[serviceKey];
+  const serviceNamespace = serviceConfig && getServiceNamespace(serviceConfig);
+  return {
+    typeName,
+    serviceKey,
+    serviceNamespace,
+    template,
+    isForeign: Boolean(serviceConfig)
+  };
+}
+export function refToRefItem(context, $ref, template) {
+  var _typeName, _serviceKey;
+
+  const shapeName = $refToShapeName($ref);
+  const shapeNameParts = shapeName.split('_');
+  let typeName;
+  let serviceKey;
+  let serviceNamespace;
+
+  if (shapeNameParts.length > 1) {
+    const namespaces = getServiceNamespaces(context);
+    const maybeNamespace = shapeNameParts[0];
+    serviceKey = namespaces.get(maybeNamespace);
+
+    if (serviceKey) {
+      typeName = shapeNameParts.slice(1).join('_');
+      serviceNamespace = maybeNamespace;
+    }
+  }
+
+  return {
+    typeName: (_typeName = typeName) !== null && _typeName !== void 0 ? _typeName : shapeName,
+    serviceKey: (_serviceKey = serviceKey) !== null && _serviceKey !== void 0 ? _serviceKey : 'local',
+    serviceNamespace,
+    template,
+    isForeign: Boolean(serviceKey)
+  };
+}
+/**
+ * Given a content schema and project schema, finds a `@ref` or `$ref` and
+ * returns a `RefItem` suitable for loading a referenced schema...
+ */
+
+export function getRef(context, refSchema) {
+  if (refSchema['@ref']) {
+    // @ref: my-service:ShapeName
+    return atRefToRefItem(context, refSchema['@ref']);
+  }
+
+  if (refSchema.$ref) {
+    // $ref: #/shapes/[ShapeName OR Namespace_TypeName]/schema
+    return refToRefItem(context, refSchema.$ref);
+  }
+}
+export function getRefWithPath(context, refSchema, schemaPath = []) {
+  const refItem = getRef(context, refSchema);
+
+  if (refItem) {
+    const refType = getRefType(refSchema);
+    return { ...refItem,
+      path: schemaPath.concat([refType])
+    };
+  }
+}
+/**
+ * Tests for a `@ref` or `$ref` property directly on the passed schema.
+ *
+ * @param schema Any schema that might could have a ref property.
+ */
+
+export function hasRefProperty(schema) {
+  var _schema$Ref;
+
+  return Boolean((_schema$Ref = schema['@ref']) !== null && _schema$Ref !== void 0 ? _schema$Ref : schema.$ref);
+}
+/**
+ * From a schema with a ref, will return the top-level ref, and potentially
+ * a ref item from a nested `items` property.
+ */
+
+export function getRefOrItemsRef(context, refSchema, schemaPath = []) {
+  const refItem = getRefWithPath(context, refSchema, schemaPath);
+
+  if (refItem) {
+    return refItem;
+  }
+
+  if (refSchema.items) {
+    return getRefOrItemsRef(context, refSchema.items, schemaPath.concat(['items']));
+  }
+}
+/**
+ * Turns a `RefItem` into an `@ref`.
+ */
+
+export function refItemToAtRef(refItem) {
+  return `${refItem.serviceKey}:${refItem.typeName}`;
+}
+/**
+ * Turns a `RefItem` into a standard shape name, namespacing if present.
+ */
+
+export function refItemToShapeName(refItem) {
+  const {
+    serviceNamespace,
+    typeName
+  } = refItem;
+  return serviceNamespace ? `${serviceNamespace}_${typeName}` : typeName;
+}
+/**
+ * Turns a `RefItem` into a path suitable for `lodash.get`.
+ */
+
+export function refItemToShapePath(refItem) {
+  return ['shapes', refItemToShapeName(refItem)];
+}
+/**
+ * Get a Shape referenced by a `RefItem`.
+ */
+
+export function refItemToShape(context, refItem) {
+  const shapePath = refItemToShapePath(refItem);
+  return get(context, shapePath);
+}
+/**
+ * Get a Shape schema referenced by a `RefItem`.
+ */
+
+export function refItemToShapeSchema(context, refItem) {
+  const shapePath = refItemToShapePath(refItem);
+  return get(context, [...shapePath, 'schema']);
+}
+/**
+ * Sugar, for when you really just need a string...
+ */
+
+export function getRefShapeName(context, refSchema) {
+  const refItem = getRef(context, refSchema);
+  return refItem ? refItemToShapeName(refItem) : undefined;
+}
+/**
+ * Sugar, for when you really just need a path...
+ */
+
+export function anyRefToShapeSchemaPath(context, refSchema) {
+  const refItem = getRef(context, refSchema);
+  return refItem ? [...refItemToShapePath(refItem), 'schema'] : undefined;
+}
+/**
+ * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
+ */
+
+export const omitRefAndExtend = (targetSchema, sourceSchema) => assign(omit(['@ref', '$ref'], targetSchema), sourceSchema);
+/**
+ * If there is a $ref, this will insert a content schema from the top level
+ * in place of the reference.
+ */
+
+export function followRef(context, contentSchema) {
+  const refItem = getRef(context, contentSchema);
+
+  if (refItem) {
+    const referencedSchema = refItemToShapeSchema(context, refItem);
+
+    if (referencedSchema) {
+      return omitRefAndExtend(contentSchema, referencedSchema);
+    }
+  }
+
+  return contentSchema;
+}
+/**
+ * Returns whether a schema has refs.
+ */
+
+export function hasRef(contentSchema) {
+  if (isRefSchema(contentSchema) || isRefSchemaLegacy(contentSchema)) {
+    return true;
+  }
+
+  if (isAllOfSchema(contentSchema)) {
+    return Boolean(contentSchema.allOf.find(hasRef));
+  }
+
+  if (isOneOfSchema(contentSchema)) {
+    return Boolean(contentSchema.oneOf.find(hasRef));
+  }
+
+  return false;
+}
+/**
+ * Returns whether a schema has refs which can be followed.
+ */
+
+export function hasResolvableRef(context, contentSchema) {
+  if (isRefSchema(contentSchema) || isRefSchemaLegacy(contentSchema)) {
+    return Boolean(refItemToShapeSchema(context, getRef(context, contentSchema)));
+  }
+
+  if (isAllOfSchema(contentSchema)) {
+    return Boolean(contentSchema.allOf.find(s => hasResolvableRef(context, s)));
+  }
+
+  if (isOneOfSchema(contentSchema)) {
+    return Boolean(contentSchema.oneOf.find(s => hasResolvableRef(context, s)));
+  }
+
+  return false;
+}

package/es/resolvers.js

@@ -0,0 +1,2 @@
+export const modelResolvers = ['takeshape:get', 'takeshape:list', 'takeshape:create', 'takeshape:update', 'takeshape:delete', 'takeshape:duplicate', 'takeshape:find'];
+export const resolverList = [...modelResolvers, 'graphql:query', 'graphql:mutation', 'rest:get', 'rest:head', 'rest:post', 'rest:put', 'rest:patch', 'rest:delete', 'debug:noop', 'util:wrap', 'awsLambda:invoke'];

package/es/scalars.js

@@ -0,0 +1,4 @@
+export const scalars = ['string', 'boolean', 'integer', 'number'];
+export function isScalar(str) {
+  return Array.from(scalars).includes(str);
+}