@takeshape/schema 7.194.0

package/es/services.js

@@ -0,0 +1,379 @@
+import { upperCamel, deepClone } from '@takeshape/util';
+import { mergeWithArrayMerge } from '@takeshape/util/lib/merge';
+import { isEncryptedServiceConfig, isAnyServiceConfig } from './types';
+import projectMetaSchema from './schemas/project-schema/v3.1.0.json';
+import { createSchemaValidator } from '@takeshape/json-schema';
+import isObject from 'lodash/isObject';
+import isNull from 'lodash/isNull';
+import isString from 'lodash/isString';
+import isUndefined from 'lodash/isUndefined';
+import { getServiceInfo, SERVICE_OBJECT_PATTERN_NAME } from './schema-util';
+
+/**
+ * `graphql:my-key` `my-key`
+ */
+export function parseV3ServiceStr(service) {
+  const parts = service.split(':');
+  return {
+    provider: parts.length > 1 ? parts[0] : undefined,
+    id: parts.length > 1 ? parts[1] : parts[0]
+  };
+}
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+
+export function decryptServiceConfig(decryptFn, storedServiceConfig) {
+  let authentication;
+
+  if (isEncryptedServiceConfig(storedServiceConfig)) {
+    authentication = decryptFn(storedServiceConfig.authentication);
+  }
+
+  return { ...storedServiceConfig,
+    authentication
+  };
+}
+/**
+ * Given a `StoredServiceMap` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+
+export async function decryptServiceMap(decryptFn, storedServiceMap) {
+  return Object.entries(storedServiceMap).reduce((result, [serviceKey, serviceConfig]) => {
+    return result.set(serviceKey, decryptServiceConfig(decryptFn, serviceConfig));
+  }, new Map());
+}
+/**
+ * Provides a `ServiceConfig` validator based on the JSON-schema.
+ */
+
+function createServiceConfigValidator() {
+  const {
+    serviceConfig: schema,
+    ...definitions
+  } = projectMetaSchema.definitions;
+  const validationSchema = {
+    $id: '#serviceConfig',
+    definitions,
+    ...schema
+  };
+  return createSchemaValidator(validationSchema);
+}
+/**
+ * Provides a `ServiceAuthentication` validator. Due to a behavior of `oneOf` and
+ * the `removeAdditional` setting, where valid properties are being stripped,
+ * this is validated separate from the overall config. May have something to do with
+ * JSON Schema's lack of handling for discriminated unions?
+ */
+
+
+function createServiceAuthenticationValidator() {
+  const {
+    serviceAuthentication: schema,
+    ...definitions
+  } = projectMetaSchema.definitions;
+  const validationSchema = {
+    $id: '#serviceAuthentication',
+    definitions,
+    ...schema
+  };
+  return createSchemaValidator(validationSchema, [], {
+    removeAdditional: false
+  });
+}
+
+const serviceConfigValidator = createServiceConfigValidator();
+const serviceAuthenticationValidator = createServiceAuthenticationValidator();
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+// eslint-disable-next-line max-params
+
+export function prepareServiceUpdate(encryptFn, decryptFn, projectSchema, partialServiceConfig, serviceKey) {
+  var _projectSchema$servic;
+
+  const storedServiceConfig = (_projectSchema$servic = projectSchema.services) === null || _projectSchema$servic === void 0 ? void 0 : _projectSchema$servic[serviceKey];
+  let newServiceConfig = partialServiceConfig;
+
+  if (storedServiceConfig) {
+    const existingServiceConfig = decryptServiceConfig(decryptFn, storedServiceConfig);
+    newServiceConfig = mergeWithArrayMerge(existingServiceConfig, partialServiceConfig);
+  }
+
+  if (isNull(newServiceConfig.authentication)) {
+    delete newServiceConfig.authentication;
+  }
+
+  let authentication;
+
+  if (newServiceConfig.authentication) {
+    // Copy authentication, to ensure validation doesn't remove any properties
+    authentication = deepClone(newServiceConfig.authentication);
+    const {
+      errorsText: authenticationErrors
+    } = serviceAuthenticationValidator(authentication);
+
+    if (authenticationErrors) {
+      throw new Error(authenticationErrors);
+    }
+  }
+
+  const {
+    errorsText: configErrors
+  } = serviceConfigValidator(newServiceConfig);
+
+  if (configErrors) {
+    throw new Error(configErrors);
+  }
+
+  let serviceConfig;
+
+  if (authentication) {
+    serviceConfig = { ...newServiceConfig,
+      authentication: encryptFn(authentication)
+    };
+  } else {
+    serviceConfig = newServiceConfig;
+  }
+
+  return serviceConfig;
+}
+/**
+ * Get a service config from a project schema.
+ */
+
+export function getStoredServiceConfig(projectSchema, serviceKey) {
+  var _projectSchema$servic2;
+
+  return (_projectSchema$servic2 = projectSchema.services) === null || _projectSchema$servic2 === void 0 ? void 0 : _projectSchema$servic2[serviceKey];
+}
+/**
+ * Migration-related Functions
+ *
+ * All the following code is used in the migration process. At some point
+ * migraton code should live outside the standard runtime code.
+ */
+
+/**
+ * Ensures a consistent service config, inluding updating the service
+ * authentication object.
+ */
+// eslint-disable-next-line complexity
+
+export function updateServiceConfigV3ToV3_1(serviceConfig, serviceKey) {
+  if (isAnyServiceConfig(serviceConfig)) {
+    if (isString(serviceConfig.authentication) || isUndefined(serviceConfig.authentication)) {
+      return serviceConfig;
+    }
+
+    return serviceConfig;
+  }
+
+  const auth = serviceConfig.auth;
+  const serviceParams = serviceConfig.params || {};
+  let {
+    provider: serviceKeyProvider,
+    id: serviceKeyId
+  } = parseV3ServiceStr(serviceKey);
+  const authType = serviceParams.authType || undefined;
+  const title = serviceParams.name || serviceKeyId;
+
+  if (serviceKeyId === 'vercel') {
+    serviceKeyProvider = 'vercel';
+  } else if (serviceKeyId === 'netlify') {
+    serviceKeyProvider = 'netlify';
+  } // Example schemas had this in params, which are untyped, so adding here just in case
+
+
+  if (serviceParams.type === 'rest') {
+    serviceKeyProvider = 'rest';
+  } else if (serviceParams.type === 'graphql' && serviceKeyProvider !== 'shopify') {
+    serviceKeyProvider = 'graphql';
+  }
+
+  let provider;
+  let authenticationType;
+  let serviceType;
+  let namespace;
+
+  if (serviceKeyProvider === 'shopify') {
+    var _serviceParams$namesp;
+
+    provider = 'shopify';
+    authenticationType = 'oauth2Bearer';
+    serviceType = 'graphql';
+    namespace = (_serviceParams$namesp = serviceParams.namespace) !== null && _serviceParams$namesp !== void 0 ? _serviceParams$namesp : 'Shopify';
+  } else if (serviceKeyProvider === 'takeshape') {
+    var _serviceParams$namesp2;
+
+    provider = 'takeshape';
+    authenticationType = 'none';
+    serviceType = 'takeshape';
+    namespace = (_serviceParams$namesp2 = serviceParams.namespace) !== null && _serviceParams$namesp2 !== void 0 ? _serviceParams$namesp2 : 'TakeShape';
+  } else if (serviceKeyProvider === 'bigcommerce') {
+    var _serviceParams$namesp3;
+
+    provider = 'bigcommerce';
+    authenticationType = 'bearer';
+    serviceType = 'graphql';
+    namespace = (_serviceParams$namesp3 = serviceParams.namespace) !== null && _serviceParams$namesp3 !== void 0 ? _serviceParams$namesp3 : 'BigCommerce';
+  } else if (serviceKeyProvider === 'rest') {
+    var _serviceParams$namesp4;
+
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'rest';
+    namespace = (_serviceParams$namesp4 = serviceParams.namespace) !== null && _serviceParams$namesp4 !== void 0 ? _serviceParams$namesp4 : upperCamel(title);
+  } else if (serviceKeyProvider === 'graphql') {
+    var _serviceParams$namesp5;
+
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'graphql';
+    namespace = (_serviceParams$namesp5 = serviceParams.namespace) !== null && _serviceParams$namesp5 !== void 0 ? _serviceParams$namesp5 : upperCamel(title);
+  } else if (serviceKeyProvider === 'vercel') {
+    provider = 'vercel';
+    authenticationType = 'oauth2Bearer';
+    serviceType = 'deployment';
+  } else if (serviceKeyProvider === 'netlify') {
+    provider = 'netlify';
+    authenticationType = 'oauth2Bearer';
+    serviceType = 'deployment';
+  } else {
+    var _serviceParams$namesp6;
+
+    provider = 'generic';
+    authenticationType = mapAuthType(authType, auth);
+    serviceType = 'unknown';
+    namespace = (_serviceParams$namesp6 = serviceParams.namespace) !== null && _serviceParams$namesp6 !== void 0 ? _serviceParams$namesp6 : upperCamel(title);
+  }
+
+  const updatedServiceConfig = {
+    title,
+    id: serviceKey,
+    provider,
+    namespace,
+    serviceType,
+    authenticationType,
+    options: { ...serviceParams
+    }
+  };
+
+  if (serviceConfig.auth && isObject(serviceConfig.auth)) {
+    const authentication = updateServiceAuthentication(updatedServiceConfig.authenticationType, serviceConfig.auth, serviceParams);
+    return { ...updatedServiceConfig,
+      authentication
+    };
+  }
+
+  return updatedServiceConfig;
+}
+/**
+ * V1/V3 unencrypted `auth` -> V3.1 `authentication
+ */
+
+function updateServiceAuthentication(authenticationType, legacyAuth, legacyParams) {
+  if (authenticationType === 'oauth2Bearer') {
+    return {
+      token: legacyAuth.accessToken,
+      scope: legacyAuth.scope,
+      header: legacyParams.authHeader
+    };
+  }
+
+  if (authenticationType === 'searchParams' && legacyParams.authProp) {
+    return [{
+      name: legacyParams.authProp,
+      value: legacyAuth.accessToken
+    }];
+  }
+
+  if (authenticationType === 'basic') {
+    const [username, password] = Buffer.from(legacyAuth.accessToken, 'base64').toString('utf-8').split(':');
+    return {
+      username,
+      password
+    };
+  }
+
+  if (authenticationType === 'bearer') {
+    return {
+      token: legacyAuth.accessToken,
+      header: legacyParams.authHeader
+    };
+  }
+}
+
+function mapAuthType(authType, auth) {
+  if (authType === 'none') {
+    return 'none';
+  }
+
+  if (authType === 'searchParams') {
+    return 'searchParams';
+  }
+
+  if (authType === 'bearer') {
+    return 'bearer';
+  }
+
+  if (authType === 'bearer') {
+    return 'basic';
+  }
+
+  if (!auth) {
+    return 'none';
+  }
+
+  if (auth) {
+    return 'bearer';
+  }
+
+  return 'unknown';
+}
+
+export function getServiceNamespace(serviceConfig) {
+  var _serviceConfig$params;
+
+  if ('namespace' in serviceConfig && serviceConfig.namespace) {
+    return serviceConfig.namespace;
+  }
+
+  if ('params' in serviceConfig && (_serviceConfig$params = serviceConfig.params) !== null && _serviceConfig$params !== void 0 && _serviceConfig$params.namespace) {
+    return serviceConfig.params.namespace;
+  }
+}
+/**
+ * Get a `Map` keyed with all the service namespaces.
+ *
+ * @param context A partial project schema
+ *
+ * @returns A `Map` with namespaces as keys, and service keys as values.
+ */
+
+export function getServiceNamespaces(context) {
+  let namespaces = new Map();
+  const {
+    services
+  } = context;
+
+  if (services) {
+    Object.keys(services).forEach(serviceKey => {
+      const namespace = getServiceNamespace(services[serviceKey]);
+
+      if (namespace) {
+        namespaces.set(namespace, serviceKey);
+      }
+    });
+  }
+
+  return namespaces;
+}
+export function getServiceObjectFields(projectSchema, shape, provider) {
+  var _getServiceInfo$provi;
+
+  return ((_getServiceInfo$provi = getServiceInfo(projectSchema, shape)[provider]) !== null && _getServiceInfo$provi !== void 0 ? _getServiceInfo$provi : []).filter(serviceInfo => serviceInfo.generators[SERVICE_OBJECT_PATTERN_NAME]);
+}

package/es/taxonomies.js

@@ -0,0 +1,55 @@
+import memoize from 'lodash/memoize';
+import { createSchemaPropertyAccessor } from './schema-util';
+
+function weakMemoize(fn) {
+  const memoized = memoize(fn);
+  memoized.cache = new WeakMap();
+  return memoized;
+}
+
+export function getFirstStringFieldV3(shape, projectSchema) {
+  var _projectSchema$forms;
+
+  const forms = (_projectSchema$forms = projectSchema.forms) === null || _projectSchema$forms === void 0 ? void 0 : _projectSchema$forms[shape.name];
+
+  if (!forms || !forms.default) {
+    return null;
+  }
+
+  const schemaProperties = createSchemaPropertyAccessor(projectSchema, shape.schema);
+  const {
+    order
+  } = forms.default;
+  const name = order.find(name => {
+    var _schemaProperties$get;
+
+    return ((_schemaProperties$get = schemaProperties.getValue(name)) === null || _schemaProperties$get === void 0 ? void 0 : _schemaProperties$get.type) === 'string';
+  });
+  return name ? {
+    name,
+    key: schemaProperties.getKey(name)
+  } : null;
+}
+export const getTaxonomyField = weakMemoize((shape, projectSchema) => {
+  var _shape$model;
+
+  return ((_shape$model = shape.model) === null || _shape$model === void 0 ? void 0 : _shape$model.type) === 'taxonomy' ? getFirstStringFieldV3(shape, projectSchema) : null;
+});
+export const getTaxonomies = weakMemoize(projectSchema => {
+  const {
+    shapes
+  } = projectSchema;
+  return Object.keys(shapes).reduce((result, shapeName) => {
+    const shape = shapes[shapeName];
+    const field = getTaxonomyField(shape, projectSchema);
+
+    if (field) {
+      result.push({
+        shapeId: shape.id,
+        field
+      });
+    }
+
+    return result;
+  }, []);
+});

package/es/template-shapes.js

@@ -0,0 +1,79 @@
+import { isRefSchema } from './types';
+import { getRef, refExpressionToRefItem, refItemToShapeName } from './refs';
+export const knownTemplateShapes = new Set(['TSGetArgs', 'TSGetSingletonArgs', 'PaginatedList', 'TSListArgs', 'CreateArgs', 'UpdateArgs', 'DuplicateArgs', 'DeleteArgs', 'CreateResult', 'UpdateResult', 'DuplicateResult', 'DeleteResult']);
+/**
+ * Check if a string is a known template such as `PaginatedList`
+ */
+
+export function isValidTemplate(template) {
+  return knownTemplateShapes.has(template);
+}
+/**
+ * Parse a template like `PaginatedList<Post>` and return both the template and the shape name.
+ */
+
+export function parseTemplateShape(shape) {
+  const parts = shape.split('<');
+
+  if (parts.length > 1 && isValidTemplate(parts[0])) {
+    return {
+      shapeName: parts[1].replace(/(<|>)/, ''),
+      template: parts[0]
+    };
+  }
+
+  return {
+    shapeName: parts[0],
+    template: undefined
+  };
+}
+export function parseReturnShape(projectSchema, shape) {
+  if (typeof shape === 'object') {
+    if (isRefSchema(shape.items)) {
+      const ref = getRef(projectSchema, shape.items);
+
+      if (!ref) {
+        throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid ref`);
+      }
+
+      return {
+        isArray: true,
+        ref,
+        shapeName: refItemToShapeName(ref)
+      };
+    }
+
+    if (typeof shape.items.type !== 'string') {
+      throw new Error(`Could not parse ${JSON.stringify(shape.items)}: invalid type`);
+    }
+
+    return {
+      isArray: true,
+      shapeName: shape.items.type
+    };
+  }
+
+  const ref = refExpressionToRefItem(projectSchema, shape);
+  const shapeName = refItemToShapeName(ref);
+  return {
+    isArray: false,
+    shapeName,
+    ref,
+    template: ref.template
+  };
+}
+/**
+ * Create a template string like `PaginatedList<Post>` from a template and shape name.
+ */
+
+export function createTemplateShapeName(template, shapeName) {
+  return `${template}<${shapeName}>`;
+}
+/**
+ * If the string is a template like `PaginatedList<Post>`, return the shape name,
+ * in this case `Post`. Otherwise return the input.
+ */
+
+export const untemplate = input => {
+  return parseTemplateShape(input).shapeName;
+};