@takeshape/schema 11.40.0 → 11.41.0

package/dist/types/src/refs.d.ts

@@ -0,0 +1,227 @@
+/// <reference types="lodash" />
+import { type Maybe } from '@takeshape/util';
+import type { PropertySchema, ShapeJSON, ShapeSchema, ObjectSchema, ReturnShape, Ref, ProjectSchemaJSON, Args, QueryJSON } from './project-schema';
+import type { SchemaPath, SchemaWithRef } from './types';
+export type ServicesContext = Pick<ProjectSchemaJSON, 'services'>;
+export type ServicesShapesContext = Pick<ProjectSchemaJSON, 'services' | 'shapes'>;
+/**
+ * This interface describes a parsed `@ref` or `$ref`.
+ * The intended usage is to convert a schema with a ref to a RefItem which can then
+ * be passed to the various rich utilities in this file.
+ */
+export type RefItem = {
+    typeName: string;
+    serviceKey: string;
+    serviceNamespace?: string;
+    template?: string;
+    isForeign: boolean;
+    isValidService: boolean;
+} & Record<string, unknown>;
+/**
+ * Adds a schema path, needed when visiting a whole schema to report errors.
+ */
+export type RefItemWithPath = {
+    path: SchemaPath;
+} & RefItem;
+/**
+ * Guard for RefItemWithPath. Tests for presence of all required props.
+ */
+export declare function isRefItemWithPath(ref: Record<string, unknown>): ref is RefItemWithPath;
+/**
+ * Parse a template like `PaginatedList<Post>` and return both the template and the shape name.
+ */
+export declare function parseTemplateShape(shapeExpression: string): {
+    template: string | undefined;
+    shapeName: string;
+};
+export type ParsedReturnShape = {
+    isArray: boolean;
+    template?: string;
+    shapeName: string;
+    ref?: RefItem;
+};
+export declare function parseReturnShape(projectSchema: ServicesContext, shape: ReturnShape): ParsedReturnShape;
+/**
+ * Convert Query.shape to a PropertySchema
+ */
+export declare function returnShapeToSchema(projectSchema: ServicesContext, returnShape: ReturnShape): PropertySchema;
+/**
+ * Create a template string like `PaginatedList<Post>` from a template and shape name.
+ */
+export declare function createTemplateShapeName(template: string, shapeName: string): string;
+/**
+ * If the string is a template like `PaginatedList<Post>`, return the shape name,
+ * in this case `Post`. Otherwise return the input.
+ */
+export declare const untemplate: (input: string) => string;
+export declare function getFlattenedTemplateShapeName(shapeName: string, template?: string): string;
+export declare function $refToAtRef($ref: string, service: string, namespace?: string): string;
+export declare function refSchemaToPath(context: ServicesContext, refSchema: SchemaWithRef): string[];
+/**
+ * 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 declare function refExpressionToRefItem(context: ServicesContext, refExpression: string): RefItem;
+/**
+ * Converts a list of ref expressions into a list of ref items.
+ */
+export declare function refExpressionListToRefItemList(context: ServicesContext, refExpressionList: Ref[]): RefItem[];
+/**
+ * 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 declare function refExpressionToShape(context: ServicesShapesContext, refExpression: string): Maybe<ShapeJSON>;
+/**
+ * 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 declare function splitAtRef(atRef: string): [string, string];
+/**
+ * Parses and returns a typeName, serviceKey, and potentially a namespace for
+ * the type.
+ */
+export declare function atRefToRefItem(context: ServicesContext, atRef: string, template?: string): RefItem;
+export declare function refToRefItem(context: ServicesContext, $ref: string, template?: string): RefItem;
+export type ParsedName = {
+    namespace?: string;
+    serviceId: string;
+    name: string;
+};
+/**
+ * Parse a name (query, shape, etc) that might have a namespace and find the corresponding service layer id
+ */
+export declare function parseName(context: ServicesContext, name: string): ParsedName;
+export declare function shapeToRefItem(context: ServicesContext, shape: ShapeJSON): RefItem;
+export declare function shapeToRefString(context: ServicesContext, shape: ShapeJSON): string;
+/**
+ * Given a property schema and project schema, finds a `@ref` or `$ref` and
+ * returns a `RefItem` suitable for loading a referenced schema...
+ */
+export declare function getRef(context: ServicesContext, refSchema: SchemaWithRef): Maybe<RefItem>;
+export declare function getRefWithPath(context: ServicesContext, refSchema: SchemaWithRef, schemaPath?: SchemaPath, isInterfaceRef?: boolean): Maybe<RefItemWithPath>;
+/**
+ * Tests for a `@ref` or `$ref` property directly on the passed schema.
+ *
+ * @param schema Any schema that might could have a ref property.
+ */
+export declare function hasRefProperty(schema: SchemaWithRef): boolean;
+/**
+ * From a property that has oneOf or items with oneOf, get all refs
+ */
+export declare function getOneOfRefs(context: ServicesContext, propertySchema: PropertySchema, schemaPath?: SchemaPath): RefItemWithPath[];
+/**
+ * From a schema with a ref, will return the top-level ref, and potentially
+ * a ref item from a nested `items` property.
+ */
+export declare function getRefOrItemsRef(context: ServicesContext, refSchema: SchemaWithRef, schemaPath?: SchemaPath): Maybe<RefItemWithPath>;
+/**
+ * Turns a `RefItem` into an `@ref`.
+ */
+export declare function refItemToAtRef(refItem: RefItem): string;
+/**
+ * Turns a `RefItem` into a standard shape name, namespacing if present.
+ */
+export declare function refItemToNamespacedShapeName(refItem: RefItem): string;
+/**
+ * Turns a `RefItem` into a path suitable for `lodash.get`.
+ */
+export declare function refItemToShapePath(refItem: RefItem): string[];
+/**
+ * Get a Shape referenced by a `RefItem`.
+ */
+export declare function refItemToShape(context: ServicesShapesContext, refItem: RefItem): Maybe<ShapeJSON>;
+/**
+ * Get all shapes referenced by a RefItem array.
+ */
+export declare function refItemListToShapeList(context: ServicesShapesContext, refItems: RefItem[]): ShapeJSON[];
+/**
+ * Get a shape referenced by a `RefItem`, also returning the path to the new shape.
+ */
+export declare function refItemToShapeWithPath(context: ServicesShapesContext, refItem: RefItem): Maybe<{
+    shape: ShapeJSON;
+    path: string[];
+}>;
+/**
+ * Get a Shape schema referenced by a `RefItem`.
+ */
+export declare function refItemToShapeSchema(context: ServicesShapesContext, refItem: RefItem): Maybe<ShapeSchema>;
+/**
+ * Sugar, for when you really just need a string...
+ */
+export declare function getRefShapeName(context: ServicesContext, refSchema: SchemaWithRef): Maybe<string>;
+/**
+ * Sugar, for when you really just need a path...
+ */
+export declare function anyRefToShapeSchemaPath(context: ServicesContext, refSchema: SchemaWithRef): Maybe<string[]>;
+/**
+ * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
+ */
+export declare const omitRefAndExtend: (targetSchema: PropertySchema, sourceSchema: PropertySchema) => import("lodash").Omit<PropertySchema, "@ref" | "$ref"> & PropertySchema;
+/**
+ * If there is a $ref, this will insert a property schema from the top level
+ * in place of the reference.
+ */
+export declare function followRef(context: ServicesShapesContext, schema: PropertySchema, ref?: RefItem): PropertySchema;
+/**
+ * Returns whether a schema has refs.
+ */
+export declare function hasRef(schema: PropertySchema): boolean;
+/**
+ * Returns whether a schema has refs which can be followed.
+ */
+export declare function hasResolvableRef(context: ServicesShapesContext, schema: PropertySchema): boolean;
+/**
+ * Given a schema, will resolve any `allOf` or `ref` objects. This function has
+ * to fully resolve all refs, because attempting to extend an object schema with
+ * a ref property would create an invalid schema, potentially containing both
+ * a ref and properties.
+ *
+ * If it can't create a valid schema it returns the input.
+ */
+export declare function dereferenceSchema(context: ServicesShapesContext, shapeOrFieldSchema: PropertySchema, schemaPath?: SchemaPath): PropertySchema;
+export declare function dereferenceObjectSchema(context: ServicesShapesContext, shapeOrFieldSchema: PropertySchema, schemaPath?: SchemaPath): ObjectSchema;
+export type GetNamespace = (serviceId: string) => Maybe<string>;
+export declare function createGetNamespace(context: ServicesContext): GetNamespace;
+export type PropertyRefItem = {
+    serviceId: string;
+    shapeName: string;
+    propertyName: string;
+};
+export declare function parsePropertyRef(refStr: string): Maybe<PropertyRefItem>;
+export declare function serializePropertyRef({ shapeName, propertyName, serviceId }: PropertyRefItem): string;
+export declare function normalizePropertyRef(refStr: string): string;
+export declare function propertyRefToShapeRef(propertyRef: string): string;
+export declare function formatShapeRef(serviceId: string, shapeName: string): string;
+export declare function applyNamespace(namespace: string | undefined, name: string): string;
+export declare function propertyRefItemToResolverPath(getNamespace: GetNamespace, item: PropertyRefItem): string[];
+export declare function propertyRefItemToArgsPath(getNamespace: GetNamespace, item: PropertyRefItem): string[];
+export declare function propertyRefItemToLocalName(getNamespace: GetNamespace, item: PropertyRefItem): string;
+export declare function queryRefToLocalName(context: ServicesContext, queryRef: string): string | undefined;
+export declare function propertyRefItemToPath(getNamespace: GetNamespace, item: PropertyRefItem): string[];
+export declare function propertyRefToArgs(projectSchema: ProjectSchemaJSON, ref: string | PropertyRefItem): Maybe<Args>;
+/**
+ * Get a ref to the given shape.
+ */
+export declare function normalizeRefExpression(context: ServicesContext, refExpression: string): string;
+export declare function normalizeLocalRefString(ref: string): string;
+export declare function getAllPropertyRefs(projectSchema: ProjectSchemaJSON): PropertyRefItem[];
+export type QueryEntry = {
+    name: string;
+    query: QueryJSON;
+    ref: PropertyRefItem;
+};
+export declare function getQuery(projectSchema: ProjectSchemaJSON, queryRef: string): Maybe<QueryEntry>;
+export declare function ensureQuery(projectSchema: ProjectSchemaJSON, queryRef: string): QueryEntry;
+export declare function normalizeRefs(projectSchema: ProjectSchemaJSON, property: PropertySchema): PropertySchema;

package/dist/types/src/relationships.d.ts

@@ -0,0 +1,36 @@
+import type { Maybe } from '@takeshape/util';
+import type { ProjectSchemaJSON, ShapeMap, ShapeJSON, PropertySchema } from './project-schema';
+import type { Relationship, PropertySchemaWithRelationship, LegacyRelationship, ShapeRefs, RelationshipEnv } from './types';
+/**
+ * Turn a LegacyRelationship into a partial PropertySchemaWithRelationship.
+ */
+export declare function getRelationshipSchema(projectSchema: ProjectSchemaJSON, relationship: LegacyRelationship | Relationship): PropertySchemaWithRelationship;
+/**
+ * Get a list of refs given a property schema with a relationship resolver.
+ */
+export declare function getRelationshipShapeRefs(propertySchema: PropertySchemaWithRelationship): ShapeRefs;
+/**
+ * Get a list of shapes given a property schema with a relationship resolver.
+ */
+export declare function getRelationshipShapes(shapes: ShapeMap, refs: ShapeRefs): ShapeJSON[];
+/**
+ * Get a list of shape ids given a property schema with a relationship resolver.
+ */
+export declare function getRelationshipShapeIds(shapes: ShapeMap, refs: ShapeRefs): string[];
+/**
+ * Turn a Relationship into a LegacyRelationship object.
+ */
+export declare function getLegacyRelationship(projectSchema: ProjectSchemaJSON, relationship: Relationship): LegacyRelationship;
+/**
+ * Get relationship details from a PropertySchema.
+ */
+export declare function getRelationship(propertySchema: PropertySchema): Maybe<Relationship>;
+export declare function findExistingRelationships(projectSchema: ProjectSchemaJSON, shapes: ShapeMap): Record<string, RelationshipEnv[]>;
+/**
+ * Test whether two PropertySchemas have equal realtionships
+ */
+export declare function isEqualRelationship(a: PropertySchema, b: PropertySchema): boolean;
+/**
+ * Test whether an array of PropertySchemas have unequal relationships
+ */
+export declare function hasUnequalRelationships(relationships: PropertySchema[]): boolean;

package/dist/types/src/scalars.d.ts

@@ -0,0 +1,2 @@
+export declare const scalars: readonly ["string", "boolean", "integer", "number"];
+export declare function isScalar(str: string): str is 'string' | 'boolean' | 'integer' | 'number';

package/dist/types/src/schema-transform.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectSchemaJSON, type PropertySchema } from './project-schema';
+import { type LayerSchema } from './types';
+import { type TransformProcessFactory } from './unions';
+export type SchemaTransform = (projectSchema: LayerSchema) => LayerSchema;
+export declare function removePropertiesTransform(propertyNames: string[]): SchemaTransform;
+export declare function toName(name: string): string;
+export declare function transformOneOf(process: TransformProcessFactory): (projectSchema: ProjectSchemaJSON, schema: PropertySchema, obj: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Unwrap oneOf objects in "GraphQL oneOf" style wrapper objects
+ * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
+ * Opposite of `wrapOneOfObjects`
+ */
+export declare const unwrapOneOfObjects: (projectSchema: ProjectSchemaJSON, schema: PropertySchema, obj: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Wrap oneOf objects in "GraphQL oneOf" style wrapper objects
+ * See https://github.com/graphql/graphql-spec/pull/825 for more on "GraphQL oneOf"
+ * Opposite of `unwrapOneOfObjects`
+ */
+export declare const wrapOneOfObjects: (projectSchema: ProjectSchemaJSON, schema: PropertySchema, obj: Record<string, unknown>) => Record<string, unknown>;

package/dist/types/src/schema-util.d.ts

@@ -0,0 +1,211 @@
+/// <reference types="lodash" />
+import { type Maybe } from '@takeshape/util';
+import { type RefItem, type RefItemWithPath, type ServicesContext, type ServicesShapesContext } from './refs';
+import { type LatestProjectSchemaWithServices, type ServiceMap, type SchemaWithArgs, type SchemaPropertyName, type SchemaPropertyNode, type SchemaPath, type SchemaWithRef, type LayerSchema } from './types';
+import type { ProjectSchemaJSON, PropertySchema, QueryJSON, ShapeJSON, ShapeMap, ServiceConfig, ShapeSchema, FieldMapping } from './project-schema';
+export declare function isBuiltinShape(shapeName: string): boolean;
+export declare function isBuiltinQuery(name: string): boolean;
+export declare function isBuiltinMutation(name: string): boolean;
+export declare function isBuiltinType(projectSchema: ProjectSchemaJSON, refSchema: SchemaWithRef): boolean;
+export declare const schemaMetadataKeys: readonly ["$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive"];
+export declare const commonSchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive"];
+export declare const scalarSchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive", "format", "oneOf", "multipleOf", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum", "maxLength", "minLength", "pattern"];
+export declare const objectSchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive", "properties", "required"];
+export declare const arraySchemaKeys: readonly ["type", "default", "readOnly", "$comment", "title", "description", "@l10n", "@deprecationReason", "@tag", "@tags", "@syncLocaleStructure", "@sensitive", "items", "additionalItems", "maxItems", "minItems", "uniqueItems"];
+export declare const multipleRelationshipSchemaKeys: string[];
+export declare const nonStructuralSchemaKeys: string[];
+export declare function getServiceIdFieldName(serviceFieldName: string): string;
+export declare function getGeneratorVersion(generator: string): string;
+export declare function pathBetween(fromShape: ShapeJSON, toShape: ShapeJSON, projectSchema: ProjectSchemaJSON, depthLimit?: number): string[];
+type ShapeModelInfo = Pick<ShapeJSON, 'name' | 'model'>;
+export declare function getShapeQueriesAndMutations(shapes: ShapeModelInfo | ShapeModelInfo[]): Pick<ProjectSchemaJSON, 'queries' | 'mutations'>;
+export declare function getCommonBuiltInProperties(shape: Pick<ShapeJSON, 'id'>): Record<string, PropertySchema>;
+export declare const DEFAULT_ID_FIELD = "id";
+export declare function getIdField(obj?: {
+    idField?: string;
+}): string;
+export declare function getModelBuiltInProperties(projectSchema: Partial<Pick<ProjectSchemaJSON, 'apiVersion' | 'workflows'>>, shape: Pick<ShapeJSON, 'id' | 'workflow'>): Record<string, PropertySchema>;
+/**
+ * Return all the built in property names,
+ */
+export declare function getBuiltInPropertyNames(profile?: BuiltInPropertiesProfile): Set<string>;
+export declare enum BuiltInPropertiesProfile {
+    Model = 0,
+    Cached = 1,
+    None = 2
+}
+export declare const isBuiltInPropertyName: (name: string, profile?: BuiltInPropertiesProfile) => boolean;
+export declare function applyBuiltinPropertiesToShape(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): ShapeJSON;
+/**
+ * Get all built-in shapes that are depended on by the given project schema.
+ * Required built-in shapes are always included.
+ */
+export declare function getBuiltinsUsed(projectSchema: ProjectSchemaJSON): ShapeMap;
+export declare function applyDefaultsToSchema<T extends ProjectSchemaJSON>(projectSchema: T): T;
+export declare function getShapeByRef(projectSchema: ServicesShapesContext, shapeRef: string): ShapeJSON | undefined;
+export declare function getArgsReference(projectSchema: ServicesContext, argsSchema: SchemaWithArgs): Maybe<RefItem>;
+export declare function getArgsReferenceWithPath(context: ServicesContext, argsSchema: SchemaWithArgs, schemaPath?: SchemaPath): Maybe<RefItemWithPath>;
+export declare function getArgsShapeSchema(context: ServicesShapesContext, argsSchema: SchemaWithArgs): Maybe<ShapeSchema>;
+export declare function shapeToPropertySchema(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): PropertySchema;
+export declare function projectSchemaToJSONSchema(projectSchema: ProjectSchemaJSON): {
+    definitions: Record<string, PropertySchema>;
+};
+export declare function getShapeDependencies(projectSchema: ProjectSchemaJSON, shape: ShapeJSON, predicate?: (propSchema: PropertySchema) => boolean): string[];
+type GetRelevantShapesParams = {
+    shapeNames?: string[];
+    shapeIds?: string[];
+    byId?: boolean;
+    includeDependencies?: boolean;
+};
+export declare function getRelevantShapes(projectSchema: ProjectSchemaJSON, params: GetRelevantShapesParams): ShapeMap;
+/**
+ * Visitor callback return false to stop iterating
+ */
+export type PropertyVisitorCallback = ((schema: PropertySchema, path: SchemaPath) => boolean) | ((schema: PropertySchema, path: SchemaPath) => void);
+export declare function visitSchemaProperties(root: PropertySchema, path: SchemaPath, callback: PropertyVisitorCallback): void;
+export declare function visitShapeProperties(shapes: ShapeMap, callback: PropertyVisitorCallback): void;
+export type RefPredicate = (ref: RefItemWithPath) => boolean;
+/**
+ * Walk through a `ProjectSchemaJSON` and collect all the `ref`s.
+ */
+export declare function getAllRefsInShapes(projectSchema: ServicesShapesContext, predicate?: RefPredicate): RefItemWithPath[];
+/**
+ * Get all refs
+ */
+export declare function getAllRefsInQuery(projectSchema: ServicesShapesContext, queryPath: string[], query: QueryJSON, predicate?: (ref: RefItemWithPath) => boolean): RefItemWithPath[];
+/**
+ * Collect refs from `queries` or `mutations`.
+ */
+export declare function getAllRefsInQueries(projectSchema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes' | 'services'>, rootPropertyName: 'queries' | 'mutations', predicate?: RefPredicate): RefItemWithPath[];
+/**
+ * Get all refs in a ProjectSchemaJSON
+ * @param predicate return true to include the ref in
+ */
+export declare function getAllRefs(projectSchema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes' | 'services'>, predicate?: RefPredicate): RefItemWithPath[];
+export declare function isValidRefItem(refItem: RefItem): boolean;
+/**
+ * Get all valid refs in a ProjectSchemaJSON
+ * @param predicate return true to include the ref in
+ */
+export declare function getAllValidRefs(projectSchema: Pick<ProjectSchemaJSON, 'queries' | 'mutations' | 'shapes' | 'services'>, predicate?: RefPredicate): RefItemWithPath[];
+export type Mapping = {
+    providerId: string;
+    serviceId: string;
+    shapeName: string;
+    key: string;
+};
+export declare function parseMapping(mapping: string): Mapping;
+export declare function splitMapping(mapping: string): string[];
+export declare function findMapping(schema: PropertySchema, predicate: (mappingStr: string) => boolean): string | undefined;
+export declare function getFirstMapping(schema: PropertySchema): string | undefined;
+export declare function getFullyQualifiedShapeName(schema: PropertySchema): string | undefined;
+/**
+ * Find key for use storing data in ShapeDB or API Indexing this allows renaming of properties without db migration
+ * Mapping must be using the shapedb service id
+ * @param schema
+ */
+export declare function getStorageKey(schema: PropertySchema): string | undefined;
+export declare function getPropertyService(schema: PropertySchema): string | undefined;
+export declare function emptySchema(projectId: string): ProjectSchemaJSON;
+export declare function createLayerSchema(partialSchema?: Partial<LayerSchema>): LayerSchema;
+export declare function getShapesById(projectSchema: ProjectSchemaJSON): ShapeMap;
+/**
+ * Walk through the project schema and return an array of all
+ * referenced shape names that are in a service namespace.
+ *
+ * @param projectSchema A V3 project schema.
+ *
+ * @returns A `string` array with all the shapes that are in namespaces.
+ */
+export declare function getAllNamespaceShapes(projectSchema: ProjectSchemaJSON): string[];
+/**
+ * Returns a list of all shape names in a service namespace, excluding any
+ * that have been set directly in the project schema
+ *
+ * @todo It's unsound to discard dependencies in this way, should avoid
+ *       collisions with aliases or similar any remote shape that collides,
+ *       e.g., Shopify_Product -> Shopify_Product_2
+ *
+ * @param projectSchema A V3 project schema with remote service configs.
+ *
+ * @returns A `Set` of shape names.
+ */
+export declare function getNamespacedShapeNameList(projectSchema: LatestProjectSchemaWithServices): Set<string>;
+/**
+ * Filter the service map to return only services passing the GraphQL Service
+ * typeguard.
+ *
+ * @param serviceMap A service map.
+ *
+ * @returns A new map with the filtered list of services
+ */
+export declare function filterGraphQLServiceMap(serviceMap: ServiceMap): Map<string, ServiceConfig>;
+/**
+ * Creates a schema property list chainable fn, allowing you to manipulate and
+ * iterate the properties in a schema.
+ */
+export declare const createSchemaPropertyList: import("lodash").CurriedFunction2<ServicesShapesContext, PropertySchema | ShapeJSON, {
+    _propertyIterator: Map<string, PropertySchema>;
+    orderBy: (iteratees?: ((n: SchemaPropertyNode) => string)[], orders?: ("asc" | "desc")[]) => any;
+    sortWith: (comparator?: ((a: SchemaPropertyNode, b: SchemaPropertyNode) => number) | undefined) => any;
+    sortByNamesWithList: (comparatorArray?: string[]) => any;
+    filterBy: (predicate: (n: SchemaPropertyNode) => boolean) => any;
+    forEach: (iteratee: (n: SchemaPropertyNode) => void) => any;
+    getNodes: () => SchemaPropertyNode[];
+    getObject: () => Record<string, PropertySchema>;
+    getNames: () => SchemaPropertyName[];
+    getValues: () => PropertySchema[];
+}>;
+declare class SchemaPropertyAccessor {
+    private readonly schema;
+    private readonly properties;
+    private readonly entries;
+    constructor(context: ServicesShapesContext, shapeOrSchema: PropertySchema | ShapeJSON);
+    getValue(propertyName: SchemaPropertyName): Maybe<PropertySchema>;
+    findValue(predicate: (n: SchemaPropertyNode) => boolean): Maybe<PropertySchema>;
+    findName(predicate: (n: SchemaPropertyNode) => boolean): Maybe<SchemaPropertyName>;
+    getKey(propertyName: SchemaPropertyName): Maybe<string>;
+}
+export type { SchemaPropertyAccessor };
+/**
+ * Creates a schema property accessor, allowing you to safely access schema
+ * properties.
+ */
+export declare const createSchemaPropertyAccessor: import("lodash").CurriedFunction2<ServicesShapesContext, PropertySchema | ShapeJSON, SchemaPropertyAccessor>;
+export type QueryMutationSlice = Pick<ProjectSchemaJSON, 'queries' | 'mutations'>;
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+export declare const findQueryByShape: (projectSchema: QueryMutationSlice, shapeName: string, resolver: string) => string | undefined;
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+export declare const findMutationByShape: (projectSchema: QueryMutationSlice, shapeName: string, resolver: string) => string | undefined;
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ * Throw an error if that query does not exist
+ */
+export declare const ensureQueryByShape: (projectSchema: QueryMutationSlice, shapeName: string, resolver: string) => string;
+/**
+ * Find the mutation in the schema that corresponds to the given shape and resolver.
+ * Throw an error if that mutation does not exist
+ */
+export declare const ensureMutationByShape: (projectSchema: QueryMutationSlice, shapeName: string, resolver: string) => string;
+export type ResolverWithDefaultMutation = 'shapedb:create' | 'shapedb:update' | 'shapedb:delete' | 'shapedb:duplicate';
+/**
+ * Find the query in the schema that corresponds to the given shape and resolver.
+ */
+export declare const getDefaultMutationName: (shapeName: string, resolver: ResolverWithDefaultMutation) => string;
+export declare function createShape(name: string, schema: ShapeSchema, rest?: Partial<ShapeJSON>): ShapeJSON;
+export declare function queryToPropertySchema(projectSchema: ProjectSchemaJSON, query: QueryJSON): PropertySchema;
+export declare function getQueriesShape(projectSchema: ProjectSchemaJSON, operation: 'query' | 'mutation'): ShapeJSON;
+export declare function fieldMappingContainsKey(fieldMapping: FieldMapping, key: string): boolean;
+/**
+ * Return true if `schemaWithRef` is a ref to a shape named `shapeName`
+ */
+export declare function schemaMatchesShapeName(workingCopy: ProjectSchemaJSON, propertySchema: PropertySchema, shapeName: string): boolean;
+/**
+ * Return true if `shape` has a property that is an array of refs to `shapeName`
+ */
+export declare const shapeHasArrayPropOfShape: (projectSchema: ProjectSchemaJSON, shape: ShapeJSON, shapeName: string) => boolean;
+export declare const getQueryMapName: (type: 'query' | 'mutation') => 'queries' | 'mutations';

package/dist/types/src/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export declare const CURRENT_SCHEMA_VERSION = "3.50.0";
+export { default as anyProjectSchema } from './project-schema.json';
+export { default as latestSchemaJson } from './project-schema/v3.50.0.json';
+export { default as authSchemaJson } from './auth-schemas.json';
+export { default as experimentalSchemaJson } from './project-schema/experimental.json';
+export declare const allProjectSchemas: any[];

package/dist/types/src/services/services.d.ts

@@ -0,0 +1,31 @@
+import type { Overwrite } from '@takeshape/util';
+import { type ProjectSchemaJSON, type ServiceMapJSON, type ServiceConfigJSON, type ServiceConfig, type ShapeJSON } from '../project-schema';
+import type { ServiceMap, ServiceInfo, PatternGenerator, ServiceConfigUpdate } from '../types/types';
+import { SERVICE_OBJECT_PATTERN_NAME } from '../constants';
+import { type EncryptFn, type DecryptFn } from './types';
+/**
+ * Given a `StoredServiceConfig` returns a usable `ServiceConfig` with the
+ * authentication object decrypted.
+ */
+export declare function decryptServiceConfig(decryptFn: DecryptFn, storedServiceConfig: ServiceConfigJSON): ServiceConfig;
+/**
+ * Given a `ServiceMapJSON` returns a usable `ServiceMap` with all the
+ * authentication objects decrypted.
+ */
+export declare function decryptServiceMap(decryptFn: DecryptFn, ServiceMapJSON: ServiceMapJSON): Promise<ServiceMap>;
+/**
+ * Validates a `ServiceConfig` validator based on the JSON-schema.
+ */
+export declare function validateServiceConfig(maybeServiceConfig: unknown): ServiceConfigJSON;
+/**
+ * Prepare a `ServiceConfig` object update, validating the overall structure
+ * and encrypting the `ServiceAuthentication` object.
+ */
+export declare function prepareServiceUpdate(encryptFn: EncryptFn, decryptFn: DecryptFn, projectSchema: ProjectSchemaJSON, serviceConfigUpdate: ServiceConfigUpdate, serviceKey: string): ServiceConfigJSON;
+export type ServiceInfoWithServiceObject = Overwrite<ServiceInfo, {
+    generators: {
+        [SERVICE_OBJECT_PATTERN_NAME]: PatternGenerator;
+    };
+}>;
+export declare function getServiceObjectFields(projectSchema: ProjectSchemaJSON, shape: ShapeJSON, provider: string): ServiceInfoWithServiceObject[];
+export declare function getServiceInfo(projectSchema: ProjectSchemaJSON, shape: ShapeJSON): Record<string, ServiceInfo[]>;

package/dist/types/src/services/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Decrypt an encrypted authentication JSON string
+ * Throws an error if decryption fails
+ */
+export type DecryptFn = (authentication: string) => object;
+/**
+ * Decrypt an encrypted authentication JSON string
+ * Returns undefined if decryption fails
+ */
+export type SafeDecryptFn = (authentication: string) => object | undefined;
+export type EncryptFn = (authentication: object) => string;

package/dist/types/src/services/util.d.ts

@@ -0,0 +1,16 @@
+import { type ProjectSchemaJSON, type ServiceConfigJSON, type ServiceConfig, type Resolver } from '../project-schema';
+import { type ServiceKey } from '../types';
+/**
+ * Get a service config from a project schema.
+ */
+export declare function getStoredServiceConfig(projectSchema: ProjectSchemaJSON, serviceKey: ServiceKey): ServiceConfigJSON | undefined;
+/**
+ * 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 declare function getServiceNamespaces(context: Pick<ProjectSchemaJSON, 'services'>): Map<string, string>;
+export declare function isMissingAuth(service: Pick<ServiceConfig | ServiceConfigJSON, 'authenticationType' | 'authentication'>): boolean;
+export declare function getResolverServices(resolver: Resolver): string[];

package/dist/types/src/taxonomies.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectSchemaJSON, ShapeJSON } from './project-schema';
+export type TaxonomyField = {
+    name: string;
+    key?: string;
+};
+export type Taxonomy = {
+    shapeId: string;
+    field: TaxonomyField;
+};
+export declare function getFirstStringFieldV3(shape: ShapeJSON, projectSchema: ProjectSchemaJSON): {
+    name: string;
+    key?: string;
+} | null;
+export declare const getTaxonomyField: (shape: ShapeJSON, projectSchema: ProjectSchemaJSON) => TaxonomyField | null;
+export declare const getTaxonomies: (projectSchema: ProjectSchemaJSON) => Taxonomy[];

package/dist/types/src/template-shapes/index.d.ts

@@ -0,0 +1,7 @@
+import { type ProjectSchemaJSON } from '../project-schema';
+import { type ResolvedTemplate } from './types';
+export declare function resolveTemplate(projectSchema: ProjectSchemaJSON, templateName: string, shapeName: string): ResolvedTemplate;
+/**
+ * Check if a string is a known template such as `PaginatedList`
+ */
+export declare function isValidTemplate(template: string): boolean;

package/dist/types/src/template-shapes/names.d.ts

@@ -0,0 +1,10 @@
+import { type TemplateVerbs } from './types';
+/**
+ * Construct a shape name used for a mutation input shape.
+ */
+export declare function getMutationInputShapeName(verb: TemplateVerbs): (shapeName: string) => string;
+/**
+ * Create a shape name variant for an input.
+ */
+export declare function getInputShapeName(shapeName: string): string;
+export declare function getOutputShapeName(name: string): string;

package/dist/types/src/template-shapes/templates.d.ts

@@ -0,0 +1,32 @@
+import type { ObjectSchema, PropertySchema, ShapeJSON } from '../project-schema';
+import { TemplateVerbs } from './types';
+import type { ResolvedTemplate, TemplateContext } from './types';
+export declare const TSGetArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSGetSingletonArgs: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSListArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSSearchArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const CreateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const UpdateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DuplicateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DeleteArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare const PaginatedList: typeof getPaginatedListShape;
+export declare const SearchResults: typeof getSearchResultsShape;
+export declare const CreateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const UpdateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DuplicateResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const DeleteResult: (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const TSSearchSortInput: ShapeJSON;
+export declare const commonSearchProps: Record<string, PropertySchema>;
+export declare const localeProps: ObjectSchema;
+export declare const termsProps: ObjectSchema;
+export declare const TSContentStructureInput: ShapeJSON;
+export declare function getPaginatedListShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getSearchResultsShape(context: unknown, shape: ShapeJSON): ResolvedTemplate;
+export declare function getIDQueryArgs(templateName: string): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+/**
+ * Construct shapes for a mutation inputs, given source shape info.
+ */
+export declare function getMutationArgs(templateName: string, verb: TemplateVerbs): ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
+export declare function getMutationResultType(verb: TemplateVerbs): (context: unknown, shape: ShapeJSON) => ResolvedTemplate;
+export declare const commonSearchArgs: ObjectSchema;
+export declare function getShapeListQueryArgs(templateName: string, legacyArgs: boolean): (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;