@takeshape/schema 9.49.0 → 9.49.2

package/dist/validate.js

@@ -22,14 +22,10 @@ var _errors = require("@takeshape/errors");
 
 var _coerce2 = _interopRequireDefault(require("semver/functions/coerce"));
 
-var _satisfies = _interopRequireDefault(require("semver/functions/satisfies"));
-
 var _neq = _interopRequireDefault(require("semver/functions/neq"));
 
 var _lt = _interopRequireDefault(require("semver/functions/lt"));
 
-var _gt = _interopRequireDefault(require("semver/functions/gt"));
-
 var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
 
 var _versions = require("./versions");
@@ -56,12 +52,8 @@ var _unions = require("./unions");
 
 var _enum = require("./enum");
 
-var _metaSchemaV = _interopRequireDefault(require("./schemas/project-schema/meta-schema-v3.9.0.json"));
-
 var _util = require("@takeshape/util");
 
-var _forOwn = _interopRequireDefault(require("lodash/forOwn"));
-
 var _uniqBy = _interopRequireDefault(require("lodash/uniqBy"));
 
 var _initial = _interopRequireDefault(require("lodash/initial"));
@@ -72,10 +64,6 @@ var _relationships = require("./relationships");
 
 var _get = _interopRequireDefault(require("lodash/get"));
 
-var _gte = _interopRequireDefault(require("semver/functions/gte"));
-
-var _lte = _interopRequireDefault(require("semver/functions/lte"));
-
 var _size = _interopRequireDefault(require("lodash/size"));
 
 var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
@@ -86,6 +74,8 @@ var _pMap = _interopRequireDefault(require("p-map"));
 
 var _lodash = require("lodash");
 
+var _projectSchema = require("./project-schema");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const builtInShapeNames = new Set([...Object.keys(_builtinSchema.builtInShapes), ..._scalars.scalars, 'object']);
@@ -107,18 +97,6 @@ function findDuplicates(items) {
   }));
 }
 
-function checkContentTypeNames(contentTypes) {
-  const items = Object.entries(contentTypes).map(entry => ({
-    path: ['contentType', entry[0], 'name'],
-    value: entry[1].name.toLowerCase()
-  }));
-  return findDuplicates(items).flatMap(dupe => dupe.paths.map(path => ({
-    path,
-    type: 'conflict',
-    message: `Content types must have unique names. "${dupe.value}" is not unique.`
-  })));
-}
-
 function checkShapeIds(shapes) {
   const items = Object.entries(shapes).map(entry => ({
     path: ['shapes', entry[0], 'id'],
@@ -183,25 +161,7 @@ function validateWorkflowVersion(projectSchema) {
   return errors;
 }
 
-function validateWorkflowsV1(projectSchema) {
-  const errors = validateWorkflowVersion(projectSchema);
-
-  for (const key of Object.keys(projectSchema.contentTypes)) {
-    const contentType = projectSchema.contentTypes[key];
-
-    if (contentType.workflow && contentType.workflow !== _workflows.defaultWorkflow.name && !projectSchema.workflows[contentType.workflow]) {
-      errors.push({
-        type: 'notFound',
-        path: ['contentTypes', key, 'workflow'],
-        message: `Invalid Workflow "${contentType.workflow}" for content type "${contentType.name}"`
-      });
-    }
-  }
-
-  return errors;
-}
-
-function validateWorkflowsV3(projectSchema) {
+function validateWorkflows(projectSchema) {
   const errors = validateWorkflowVersion(projectSchema);
 
   for (const name of Object.keys(projectSchema.shapes)) {
@@ -243,43 +203,21 @@ function enumerateBasicResolvers(resolver, path) {
 
 function validateResolver(projectSchema, basePath, baseResolver) {
   const errors = [];
-  /**
-   * V3.9 Resolver name enums are the set used for earlier v3 validations
-   */
-
-  const {
-    definitions: {
-      takeshapeResolver,
-      utilResolver,
-      graphqlResolver,
-      restResolver,
-      awsLambdaResolver
-    }
-  } = _metaSchemaV.default;
-
-  const isValidResolverNameV3_9_0 = resolverName => {
-    return [takeshapeResolver, utilResolver, graphqlResolver, restResolver, awsLambdaResolver].flatMap(resolver => resolver.properties.name.enum).includes(resolverName);
-  };
 
   const isValidShapeName = shapeName => {
-    var _indexedShapes, _modernShape$cache;
+    var _shape$cache;
 
     if (!shapeName) {
       return false;
     }
 
-    const shape = projectSchema.shapes[shapeName];
+    const shape = (0, _schemaUtil.getShape)(projectSchema, shapeName);
 
     if (shape !== null && shape !== void 0 && shape.model) {
       return true;
     }
 
-    if ((_indexedShapes = projectSchema.indexedShapes) !== null && _indexedShapes !== void 0 && _indexedShapes[shapeName]) {
-      return true;
-    }
-
-    const modernShape = shape;
-    return Boolean((modernShape === null || modernShape === void 0 ? void 0 : (_modernShape$cache = modernShape.cache) === null || _modernShape$cache === void 0 ? void 0 : _modernShape$cache.enabled) && modernShape.loaders);
+    return Boolean((shape === null || shape === void 0 ? void 0 : (_shape$cache = shape.cache) === null || _shape$cache === void 0 ? void 0 : _shape$cache.enabled) && shape.loaders);
   };
 
   const delegateResolverMissingConfig = (parsed, resolver) => {
@@ -296,23 +234,13 @@ function validateResolver(projectSchema, basePath, baseResolver) {
     }
   };
 
-  const isLessThanV3_9_0 = (0, _lt.default)(getSemver(projectSchema.schemaVersion), '3.9.0');
-  const isLessThanV3_31_0 = (0, _lt.default)(getSemver(projectSchema.schemaVersion), '3.31.0');
   const getNamespace = (0, _refs.createGetNamespace)(projectSchema);
 
   for (const [resolver, path] of enumerateBasicResolvers(baseResolver, basePath)) {
     if ((0, _utils.isBasicResolver)(resolver)) {
-      var _projectSchema$servic, _projectSchema$servic2;
-
-      if (isLessThanV3_31_0 && 'service' in resolver && resolver.service !== 'takeshape:local' && !((_projectSchema$servic = projectSchema.services) !== null && _projectSchema$servic !== void 0 && _projectSchema$servic[resolver.service])) {
-        errors.push({
-          type: 'notFound',
-          path: path.concat(['service']),
-          message: `Invalid service "${resolver.service}"`
-        });
-      }
+      var _projectSchema$servic;
 
-      if (!isLessThanV3_31_0 && 'service' in resolver && resolver.service !== 'shapedb' && resolver.service !== 'takeshape' && !((_projectSchema$servic2 = projectSchema.services) !== null && _projectSchema$servic2 !== void 0 && _projectSchema$servic2[resolver.service])) {
+      if ('service' in resolver && resolver.service !== 'shapedb' && resolver.service !== 'takeshape' && !((_projectSchema$servic = projectSchema.services) !== null && _projectSchema$servic !== void 0 && _projectSchema$servic[resolver.service])) {
         errors.push({
           type: 'notFound',
           path: path.concat(['service']),
@@ -320,32 +248,6 @@ function validateResolver(projectSchema, basePath, baseResolver) {
         });
       }
 
-      if (isLessThanV3_9_0 && !isValidResolverNameV3_9_0(resolver.name)) {
-        errors.push({
-          type: 'notFound',
-          path: path.concat(['name']),
-          message: `Invalid resolver name "${resolver.name}"`
-        });
-      }
-
-      if (isLessThanV3_9_0 && resolver.name.startsWith('takeshape')) {
-        var _options;
-
-        if ((_options = resolver.options) !== null && _options !== void 0 && _options.model) {
-          var _options2;
-
-          const shapeName = (_options2 = resolver.options) === null || _options2 === void 0 ? void 0 : _options2.model;
-
-          if (!isValidShapeName(shapeName)) {
-            errors.push({
-              type: 'notFound',
-              path: path.concat(['options', 'model']),
-              message: `Invalid Model Shape "${shapeName ?? ''}"`
-            });
-          }
-        }
-      }
-
       if (resolver.shapeName) {
         const {
           shapeName
@@ -497,7 +399,7 @@ function listShapeJoins(projectSchema) {
   for (const shapeKey of Object.keys(projectSchema.shapes)) {
     const shape = projectSchema.shapes[shapeKey];
 
-    if ('joins' in shape) {
+    if (shape.joins) {
       for (const joinRef of Object.keys(shape.joins)) {
         const join = shape.joins[joinRef];
         joins.push({
@@ -563,34 +465,12 @@ async function validateShapeJoins(context, projectSchema) {
   return (0, _lodash.flatten)(await Promise.all(promises));
 }
 
-function validateIndexedShapeConfig(projectSchema, shapeName, config) {
-  var _config$queries;
-
-  const errors = [];
-
-  if ((_config$queries = config.queries) !== null && _config$queries !== void 0 && _config$queries.list) {
-    (0, _util.ensureArray)(config.queries.list).forEach((list, i) => {
-      if (projectSchema.queries[list.name] === undefined) {
-        errors.push({
-          path: Array.isArray(config.queries.list) ? ['indexedShapes', shapeName, 'queries', 'list', i, 'name'] : ['indexedShapes', shapeName, 'queries', 'list', 'name'],
-          type: 'notFound',
-          message: `Invalid query "${list.name}"`
-        });
-      }
-    });
-  }
-
-  return errors;
-}
-
 function validateShapeLoaders(projectSchema, shape) {
   const errors = [];
 
-  if ('loaders' in shape) {
-    var _loaders, _loaders2;
-
+  if (shape.loaders) {
     const getNamespace = (0, _refs.createGetNamespace)(projectSchema);
-    const listLoader = (_loaders = shape.loaders) === null || _loaders === void 0 ? void 0 : _loaders.list;
+    const listLoader = shape.loaders.list;
 
     if (listLoader) {
       (0, _util.ensureArray)(listLoader).forEach((config, i) => {
@@ -607,7 +487,7 @@ function validateShapeLoaders(projectSchema, shape) {
       });
     }
 
-    const getLoader = (_loaders2 = shape.loaders) === null || _loaders2 === void 0 ? void 0 : _loaders2.get;
+    const getLoader = shape.loaders.get;
 
     if (getLoader) {
       const ref = (0, _refs.parsePropertyRef)(getLoader.query);
@@ -636,71 +516,50 @@ function visitProperties(projectSchema, callback) {
 
 function validateIndexedShapes(projectSchema) {
   const errors = [];
-  const version = getSemver(projectSchema.schemaVersion);
-
-  if ((0, _gt.default)(version, '3.12.0') && (0, _lte.default)(version, '3.31.0')) {
-    const {
-      indexedShapes
-    } = projectSchema;
-
-    if (indexedShapes) {
-      (0, _forOwn.default)(indexedShapes, (config, shapeName) => {
-        errors.push(...validateIndexedShapeConfig(projectSchema, shapeName, config));
-      });
-    }
-  } else if ((0, _gt.default)(version, '3.31.0')) {
-    const {
-      shapes
-    } = projectSchema;
+  const {
+    shapes
+  } = projectSchema;
 
-    for (const shape of Object.values(shapes)) {
-      const newErrors = validateShapeLoaders(projectSchema, shape);
+  for (const shape of Object.values(shapes)) {
+    const newErrors = validateShapeLoaders(projectSchema, shape);
 
-      if (newErrors.length) {
-        errors.push(...newErrors);
-      }
+    if (newErrors.length) {
+      errors.push(...newErrors);
     }
   }
 
-  if ((0, _gt.default)(version, '3.26.0')) {
-    let nestedCount = 0;
-    visitProperties(projectSchema, (property, propertyPath) => {
-      const indexed = property['@indexed'];
+  let nestedCount = 0;
+  visitProperties(projectSchema, (property, propertyPath) => {
+    const indexed = property['@indexed'];
 
-      if ((0, _util.isRecord)(indexed) && indexed.nested) {
-        nestedCount += 1;
+    if ((0, _util.isRecord)(indexed) && indexed.nested) {
+      nestedCount += 1;
 
-        if (property.type !== 'array') {
-          errors.push({
-            path: propertyPath,
-            type: 'location',
-            message: 'Nested indexes may only appear next to fields of type: "array"'
-          });
-        }
+      if (property.type !== 'array') {
+        errors.push({
+          path: propertyPath,
+          type: 'location',
+          message: 'Nested indexes may only appear next to fields of type: "array"'
+        });
       }
-    });
-
-    if (nestedCount > 50) {
-      errors.push({
-        path: ['shapes'],
-        type: 'tooMany',
-        message: `${nestedCount} nested indexes found`
-      });
     }
+  });
+
+  if (nestedCount > 50) {
+    errors.push({
+      path: ['shapes'],
+      type: 'tooMany',
+      message: `${nestedCount} nested indexes found`
+    });
   }
 
   return errors;
 }
-
-function getModelShapeIds(shapes) {
-  return Object.values(shapes).filter(shape => shape.model).map(shape => shape.id);
-}
-
-const builtInModelShapeIds = getModelShapeIds(_builtinSchema.builtInShapes);
 /**
  * Verify the path has an allOf schema and not just prop named "allOf"
  */
 
+
 function isAllOfPath(path) {
   const index = path.indexOf('allOf');
   return index !== -1 && (0, _util.isIntegerLike)(path[index + 1]);
@@ -817,31 +676,9 @@ function visitShapePropertiesJson(projectSchema, callback) {
   }, undefined);
 }
 
-function validateDirectives(projectSchema, additionalShapeIds = builtInModelShapeIds) {
+function validateDirectives(projectSchema) {
   const errors = [];
-  const projectShapeIds = new Set([...getModelShapeIds(projectSchema.shapes), ...additionalShapeIds]);
-  const isLessThanV3_18_0 = (0, _lt.default)(getSemver(projectSchema.schemaVersion), '3.18.0');
   visitShapePropertiesJson(projectSchema, (property, propertyPath) => {
-    if (isLessThanV3_18_0) {
-      const propSchema = property;
-
-      if (propSchema['@relationship']) {
-        var _propSchema$Relation;
-
-        const shapeIds = (_propSchema$Relation = propSchema['@relationship']) === null || _propSchema$Relation === void 0 ? void 0 : _propSchema$Relation.shapeIds;
-        shapeIds.forEach(shapeId => {
-          if (!projectShapeIds.has(shapeId)) {
-            const propPath = propertyPath.concat('@relationship');
-            errors.push({
-              type: 'notFound',
-              path: propPath,
-              message: `Invalid shapeId relationship "${shapeId}" for property "${propPath[4]}" in shape "${propPath[1]}"`
-            });
-          }
-        });
-      }
-    }
-
     const resolver = property['@resolver'];
 
     if (resolver) {
@@ -978,10 +815,6 @@ function validateShapeImplementsInterface(projectSchema, shape, interfaceShapeNa
 }
 
 function validateInterfaceImplementations(projectSchema) {
-  if (!(0, _gte.default)(getSemver(projectSchema.schemaVersion), '3.21.0')) {
-    return [];
-  }
-
   const errors = [];
 
   for (const shape of Object.values(projectSchema.shapes)) {
@@ -1011,10 +844,6 @@ function validateInterfaceImplementations(projectSchema) {
 }
 
 function validateInterfaces(projectSchema) {
-  if (!(0, _gte.default)(getSemver(projectSchema.schemaVersion), '3.21.0')) {
-    return [];
-  }
-
   const errors = []; // Validate interface shapes must be an object schema with at least one property
 
   for (const shape of Object.values(projectSchema.shapes)) {
@@ -1139,53 +968,15 @@ function formatValidationResult(context, errors, schema) {
   };
 }
 
-const validators = [{
-  range: '^1.0.0',
-
-  validateSyntax(schemaVersion, context, obj) {
-    const schemaV1 = obj;
-    let errors = [];
-    errors = errors.concat(checkContentTypeNames(schemaV1.contentTypes)).concat(validateWorkflowsV1(schemaV1)).concat(checkWorkflowStepNames(schemaV1.workflows)).concat(checkWorkflowStepKeys(schemaV1.workflows));
-    return formatValidationResult(context, errors, schemaV1);
-  }
-
-}, {
-  range: '^3.0.0',
-
-  validateSyntax(schemaVersion, context, obj) {
-    const schema = obj;
-    let errors = [];
-    errors = errors.concat(checkShapeNames(schema.shapes)).concat(checkShapeIds(schema.shapes)).concat(validateWorkflowsV3(schema)).concat(validateLocalQueryConfigs(schema)).concat(validateLocalRefs(schema)).concat(validateLocalShapeJoins(schema)).concat(validateDirectives(schema)).concat(validateLocales(schema)).concat(checkWorkflowStepNames(schema.workflows)).concat(checkWorkflowStepKeys(schema.workflows)).concat(validateOneOfs(schema)).concat(validateIndexedShapes(schema)).concat(validateInterfaces(schema)).concat(validateInterfaceImplementations(schema));
-    return formatValidationResult(context, errors, schema);
-  },
-
-  async validateReferences(schemaVersion, context, obj) {
-    const schema = obj;
-    const errors = (0, _lodash.flatten)(await Promise.all([validateRefs(context, schema), validateQueryConfigs(context, schema), validateShapeJoins(context, schema)]));
-    return formatValidationResult(context, errors, schema);
-  }
-
-}];
-
-function findValidator(schemaVersion) {
-  const schemaSemVer = (0, _coerce2.default)(schemaVersion);
-
-  if (schemaSemVer) {
-    const validator = validators.find(v => (0, _satisfies.default)(schemaSemVer, v.range));
+function validateSyntax(context, schema) {
+  let errors = [];
+  errors = errors.concat(checkShapeNames(schema.shapes)).concat(checkShapeIds(schema.shapes)).concat(validateWorkflows(schema)).concat(validateLocalQueryConfigs(schema)).concat(validateLocalRefs(schema)).concat(validateLocalShapeJoins(schema)).concat(validateDirectives(schema)).concat(validateLocales(schema)).concat(checkWorkflowStepNames(schema.workflows)).concat(checkWorkflowStepKeys(schema.workflows)).concat(validateOneOfs(schema)).concat(validateIndexedShapes(schema)).concat(validateInterfaces(schema)).concat(validateInterfaceImplementations(schema));
+  return formatValidationResult(context, errors, schema);
+}
 
-    if (validator) {
-      const {
-        validateSyntax,
-        validateReferences
-      } = validator;
-      return {
-        validateSyntax: validateSyntax.bind(null, schemaVersion),
-        ...(validateReferences ? {
-          validateReferences: validateReferences.bind(null, schemaVersion)
-        } : {})
-      };
-    }
-  }
+async function validateReferences(context, schema) {
+  const errors = (0, _lodash.flatten)(await Promise.all([validateRefs(context, schema), validateQueryConfigs(context, schema), validateShapeJoins(context, schema)]));
+  return formatValidationResult(context, errors, schema);
 }
 
 const schemaUndefinedResult = {
@@ -1207,8 +998,10 @@ const invalidVersionResult = {
   }]
 };
 
-function normalizeSchemaVersion(schema) {
-  return schema.schemaVersion ?? '1';
+function normalizeSchemaVersion(obj) {
+  if ((0, _util.isRecord)(obj)) {
+    return typeof obj.schemaVersion === 'string' ? obj.schemaVersion : '1';
+  }
 }
 
 function validateSchemaSyntax(obj, options = {}) {
@@ -1216,21 +1009,13 @@ function validateSchemaSyntax(obj, options = {}) {
     return schemaUndefinedResult;
   }
 
-  const schema = obj;
-  const schemaVersion = normalizeSchemaVersion(schema);
-  const validator = findValidator(schemaVersion);
+  const schemaVersion = normalizeSchemaVersion(obj);
 
-  if (!validator) {
+  if (!schemaVersion) {
     return invalidVersionResult;
   }
 
-  const structuralValidation = validateStructure(schemaVersion, options, obj);
-
-  if (!structuralValidation.valid) {
-    return structuralValidation;
-  }
-
-  return validator.validateSyntax(options, schema);
+  return validateStructure(schemaVersion, options, obj);
 }
 /**
  * Validates a schema using a matching validation based on the `schemaVersion` property.
@@ -1246,11 +1031,9 @@ async function validateSchema(context, obj) {
     allowDisconnectedLayers: true,
     ...context
   };
-  const schema = obj;
-  const schemaVersion = normalizeSchemaVersion(schema);
-  const validator = findValidator(schemaVersion);
+  const schemaVersion = normalizeSchemaVersion(obj);
 
-  if (!validator) {
+  if (!schemaVersion) {
     return invalidVersionResult;
   }
 
@@ -1260,13 +1043,21 @@ async function validateSchema(context, obj) {
     return structuralValidation;
   }
 
-  const syntaxValidation = validator.validateSyntax(contextWithDefaults, schema);
+  const {
+    schema
+  } = structuralValidation;
+
+  if (!(0, _projectSchema.isLatestProjectSchemaJSON)(schema)) {
+    return invalidVersionResult;
+  }
+
+  const syntaxValidation = validateSyntax(contextWithDefaults, schema);
 
-  if (!syntaxValidation.valid || !validator.validateReferences || !isValidateReferencesContext(contextWithDefaults)) {
+  if (!syntaxValidation.valid || !isValidateReferencesContext(contextWithDefaults)) {
     return syntaxValidation;
   }
 
-  return validator.validateReferences(contextWithDefaults, obj);
+  return validateReferences(contextWithDefaults, schema);
 }
 
 function ensureValidLatestSchemaSyntax(obj) {

package/es/migration/to/v3.32.0.js

@@ -1,5 +1,4 @@
 import { shapeNameToRef } from '../../refs';
-import { createShape } from '../../schema-util';
 
 function migrateListQuery(listConfig) {
   const {
@@ -67,11 +66,16 @@ const migrate = async (_, projectSchema) => {
       let shape = updatedShapes[name];
 
       if (!shape) {
-        shape = createShape(name, {
-          extends: [{
-            '@ref': shapeNameToRef(projectSchema, name)
-          }]
-        });
+        shape = {
+          name,
+          id: name,
+          title: name,
+          schema: {
+            extends: [{
+              '@ref': shapeNameToRef(projectSchema, name)
+            }]
+          }
+        };
       }
 
       const loaders = queriesToLoaders(config.queries);

package/es/refs.js

@@ -3,7 +3,7 @@ import { getRefType, isAllOfSchema, isExtendsSchema, isObjectSchema, isOneOfSche
 import get from 'lodash/get';
 import assign from 'lodash/fp/assign';
 import omit from 'lodash/fp/omit';
-import { getServiceNamespace, getServiceNamespaces } from './services';
+import { getServiceNamespaces } from './services';
 import { mergeObjectSchemas } from './util/merge';
 import { resolveSchema } from 'ajv/dist/compile';
 import isString from 'lodash/isString';
@@ -202,7 +202,7 @@ export function atRefToRefItem(context, atRef, template) {
   // no service config.
 
   const serviceConfig = (_context$services = context.services) === null || _context$services === void 0 ? void 0 : _context$services[serviceKey];
-  const serviceNamespace = serviceConfig && getServiceNamespace(serviceConfig);
+  const serviceNamespace = serviceConfig === null || serviceConfig === void 0 ? void 0 : serviceConfig.namespace;
   return {
     typeName,
     serviceKey,
@@ -525,10 +525,9 @@ export function dereferenceObjectSchema(context, shapeOrFieldSchema, schemaPath
 }
 export function createGetNamespace(context) {
   return serviceId => {
-    var _context$services2;
+    var _context$services2, _context$services2$se;
 
-    const service = (_context$services2 = context.services) === null || _context$services2 === void 0 ? void 0 : _context$services2[serviceId];
-    return service && getServiceNamespace(service);
+    return (_context$services2 = context.services) === null || _context$services2 === void 0 ? void 0 : (_context$services2$se = _context$services2[serviceId]) === null || _context$services2$se === void 0 ? void 0 : _context$services2$se.namespace;
   };
 }
 export function parsePropertyRef(refStr) {

package/es/schema-util.js

@@ -693,7 +693,7 @@ function addRef(refs, ref, predicate) {
   }
 }
 /**
- * Walk through a `ProjectSchema` and collect all the `ref`s.
+ * Walk through a `ProjectSchemaJSON` and collect all the `ref`s.
  */
 
 
@@ -787,7 +787,7 @@ export function getAllRefsInQueries(projectSchema, rootPropertyName, predicate)
   return refItems;
 }
 /**
- * Get all refs in a ProjectSchema
+ * Get all refs in a ProjectSchemaJSON
  * @param predicate return true to include the ref in
  */
 

package/es/services.js

@@ -123,22 +123,6 @@ export function getStoredServiceConfig(projectSchema, serviceKey) {
 
   return (_projectSchema$servic = projectSchema.services) === null || _projectSchema$servic === void 0 ? void 0 : _projectSchema$servic[serviceKey];
 }
-export function getServiceNamespace(serviceConfig) {
-  var _serviceConfig$params;
-
-  if ('namespace' in serviceConfig && serviceConfig.namespace) {
-    return serviceConfig.namespace;
-  }
-  /**
-   * TODO This is only necessary if this fn gets called on a schema before migration.
-   * Figure that out and remove if possible.
-   **/
-
-
-  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.
  *
@@ -155,7 +139,9 @@ export function getServiceNamespaces(context) {
 
   if (services) {
     Object.keys(services).forEach(serviceKey => {
-      const namespace = getServiceNamespace(services[serviceKey]);
+      var _services$serviceKey;
+
+      const namespace = (_services$serviceKey = services[serviceKey]) === null || _services$serviceKey === void 0 ? void 0 : _services$serviceKey.namespace;
 
       if (namespace) {
         namespaces.set(namespace, serviceKey);

package/es/types/types.js

@@ -1,8 +1,3 @@
-/**
- * An alias for the latest version of the project schema. This should be the
- * only type used in most runtime code. Updating this to a new version should
- * trigger type errors that clue you in to code that needs review.
- */
 export const projectSchemaImportOptionalProps = ['projectId', 'locales', 'defaultLocale', 'author'];
 export const legacyProjectSchemaImportOptionalProps = ['created', 'updated', 'version', 'dataKey'];