@takeshape/schema 11.89.0 → 11.91.0

package/dist/flatten-templates.js

@@ -11,7 +11,7 @@ export function flattenTemplates(projectSchema) {
     const newSchema = deepClone(projectSchema);
     for (const ref of templateRefs) {
         if (ref.template && isValidTemplate(ref.template)) {
-            const { shapeName, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(ref));
+            const { shapeName, dependencies } = resolveTemplate(newSchema, ref.template, refItemToNamespacedShapeName(newSchema, ref));
             set(newSchema, ref.path, ref.path[ref.path.length - 1] === '@ref' ? `local:${shapeName}` : shapeName);
             Object.assign(newSchema.shapes, dependencies);
         }

package/dist/index.d.ts

@@ -43,6 +43,7 @@ export * from './util/form-config.ts';
 export * from './util/get-conflicting-properties.ts';
 export * from './util/get-return-shape.ts';
 export * from './util/has-arg.ts';
+export * from './util/is-asset-property.ts';
 export * from './util/merge.ts';
 export * from './util/patch-schema.ts';
 export * from './util/shapes.ts';

package/dist/index.js

@@ -41,6 +41,7 @@ export * from "./util/form-config.js";
 export * from "./util/get-conflicting-properties.js";
 export * from "./util/get-return-shape.js";
 export * from "./util/has-arg.js";
+export * from "./util/is-asset-property.js";
 export * from "./util/merge.js";
 export * from "./util/patch-schema.js";
 export * from "./util/shapes.js";

package/dist/interfaces.d.ts

@@ -1,6 +1,8 @@
 import type { OneOfSchema, ProjectSchemaJSON, PropertySchema, ShapeJSON, ShapeMap } from './project-schema/index.ts';
-import type { RefItem, ServicesShapesContext } from './refs.ts';
-export declare function isInterfaceShape(shape?: ShapeJSON): boolean;
+import { type RefItem, type ServicesShapesContext } from './refs.ts';
+export declare function isInterfaceShape(shape?: ShapeJSON): shape is ShapeJSON & {
+    type: 'interface';
+};
 export type ImplementationShapeMap = Record<string, Set<ShapeJSON>>;
 export type ImplementationShapeNameMap = Record<string, Set<string>>;
 export declare function isInterfaceRef(context: ServicesShapesContext, propertySchema: PropertySchema): boolean;

package/dist/interfaces.js

@@ -1,6 +1,6 @@
 import { isDefined } from '@takeshape/util';
 import mapValues from 'lodash/mapValues.js';
-import { getRef, normalizeRefExpression, refExpressionToRefItem, refItemToNamespacedShapeName, refItemToShape, shapeToRefItem } from "./refs.js";
+import { getRef, getShapeByRef, normalizeRefExpression, parseRef, refItemToNamespacedShapeName, refItemToShape, shapeToRefItem } from "./refs.js";
 import { isUnionSchema } from "./unions.js";
 export function isInterfaceShape(shape) {
     return shape?.type === 'interface';
@@ -36,7 +36,8 @@ export function pruneUnusedInterfaces(projectSchema, shapeMap) {
     return mapValues(shapeMap, (shape) => {
         const { interfaces } = shape;
         if (interfaces?.length) {
-            const filteredInterfaces = interfaces.filter((refExpression) => shapeMap[refItemToNamespacedShapeName(refExpressionToRefItem(projectSchema, refExpression))]);
+            const context = { ...projectSchema, shapes: shapeMap };
+            const filteredInterfaces = interfaces.filter((refExpression) => getShapeByRef(context, refExpression));
             if (interfaces.length !== filteredInterfaces.length) {
                 return { ...shape, interfaces: filteredInterfaces };
             }
@@ -45,13 +46,13 @@ export function pruneUnusedInterfaces(projectSchema, shapeMap) {
     });
 }
 function compareRefItems(refItem1, refItem2) {
-    return refItem1.typeName === refItem2.typeName && refItem1.serviceKey === refItem2.serviceKey;
+    return refItem1.shapeName === refItem2.shapeName && refItem1.layerId === refItem2.layerId;
 }
 export function getImplementingShapes(context, interfaceRef) {
     const shapeMap = context.shapes;
     const implementingShapes = [];
     for (const shape of Object.values(shapeMap)) {
-        if (shape.interfaces?.find((interfaceRefExpression) => compareRefItems(refExpressionToRefItem(context, interfaceRefExpression), interfaceRef))) {
+        if (shape.interfaces?.find((interfaceRefExpression) => compareRefItems(parseRef(context, interfaceRefExpression), interfaceRef))) {
             implementingShapes.push(shape);
         }
     }
@@ -74,7 +75,7 @@ export function getPossibleShapeNames(projectSchema, shape) {
         names = shape.schema.oneOf
             .map((member) => {
             const ref = getRef(projectSchema, member);
-            return ref && refItemToNamespacedShapeName(ref);
+            return ref && refItemToNamespacedShapeName(projectSchema, ref);
         })
             .filter(isDefined);
     }

package/dist/migration/to/v3.34.0.js

@@ -3,15 +3,10 @@ import set from 'lodash/fp/set.js';
 import unset from 'lodash/fp/unset.js';
 import upperFirst from 'lodash/upperFirst.js';
 import { SERVICE_OBJECT_PATTERN_NAME } from "../../constants.js";
-import { getRefOrItemsRef } from "../../refs.js";
+import { getRefOrItemsRef, refItemToNamespacedShapeName } from "../../refs.js";
 import { createSchemaPropertyAccessor } from "../../schema-util.js";
 import { CURRENT_SCHEMA_VERSION } from "../../schemas/index.js";
 import { getServiceObjectFields } from "../../services/services.js";
-// Inline utilities for posterity
-function refItemToShapeName(refItem) {
-    const { serviceNamespace, typeName } = refItem;
-    return serviceNamespace ? `${serviceNamespace}_${typeName}` : typeName;
-}
 // Map of form studio widgets and their replacements in the shape editor
 const widgetMigrations = {
     object: 'shapeObject',
@@ -39,7 +34,7 @@ export function normalizeForms(projectSchema) {
             if (propSchema) {
                 const ref = getRefOrItemsRef(projectSchema, propSchema);
                 if (ref && propConfig.properties && propConfig.widget !== 'shopify') {
-                    const nestedShapeName = refItemToShapeName(ref);
+                    const nestedShapeName = refItemToNamespacedShapeName(projectSchema, ref);
                     normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
                     storeSourceForm(shapeName, formConfig, propName);
                     normalizeNested(nestedShapeName, propConfig);

package/dist/models/runtime-schema.js

@@ -1,4 +1,4 @@
-import { dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, refExpressionToRefItem, refItemToNamespacedShapeName } from "../refs.js";
+import { dereferenceSchema, getQuery, normalizePropertyRef, normalizeRefExpression, parsePropertyRef, parseRef, refItemToNamespacedShapeName } from "../refs.js";
 import { buildRuntimeSchema } from "../runtime-schema.js";
 import { getShape } from "../util/shapes.js";
 import { Query } from './query.js';
@@ -18,16 +18,16 @@ class ProjectSchemaRefResolver {
         const shapeRef = normalizeRefExpression(this.#runtimeSchemaJson, rawShapeRef);
         let shape = this.#shapeCache.get(shapeRef);
         if (!shape) {
-            const refItem = refExpressionToRefItem(this.#runtimeSchemaJson, rawShapeRef);
+            const refItem = parseRef(this.#runtimeSchemaJson, rawShapeRef);
             if (refItem) {
-                const namespacedName = refItemToNamespacedShapeName(refItem);
+                const namespacedName = refItemToNamespacedShapeName(this.#runtimeSchemaJson, refItem);
                 const shapeJson = getShape(this.#runtimeSchemaJson, namespacedName);
                 if (shapeJson) {
                     shape = new Shape(this, refItem, shapeJson);
                     this.#shapeCache.set(shapeRef, shape);
                 }
-                else if (refItem.serviceKey !== 'local') {
-                    const layerSchema = this.#layers[refItem.serviceKey]?.schema;
+                else if (refItem.layerId !== 'local') {
+                    const layerSchema = this.#layers[refItem.layerId]?.schema;
                     if (layerSchema) {
                         const shapeJson = getShape(layerSchema, namespacedName);
                         if (shapeJson) {
@@ -51,8 +51,8 @@ class ProjectSchemaRefResolver {
             }
             else {
                 const parsedRef = parsePropertyRef(queryRef);
-                if (parsedRef && parsedRef.serviceId !== 'local') {
-                    const layerSchema = this.#layers[parsedRef.serviceId]?.schema;
+                if (parsedRef && parsedRef.layerId !== 'local') {
+                    const layerSchema = this.#layers[parsedRef.layerId]?.schema;
                     if (layerSchema) {
                         const queryEntry = getQuery(layerSchema, parsedRef.propertyName);
                         if (queryEntry) {

package/dist/models/shape.d.ts

@@ -7,5 +7,6 @@ export declare class Shape {
     get name(): string;
     get ref(): string;
     get refItem(): RefItem;
+    get json(): ShapeJSON;
     getObjectSchema(): import("../project-schema/latest.ts").ObjectSchema | undefined;
 }

package/dist/models/shape.js

@@ -1,4 +1,4 @@
-import { refItemToAtRef } from "../refs.js";
+import { serializeRef } from "../refs.js";
 import { isObjectSchema } from "../types/utils.js";
 export class Shape {
     #refResolver;
@@ -14,11 +14,14 @@ export class Shape {
         return this.#shape.name;
     }
     get ref() {
-        return refItemToAtRef(this.#ref);
+        return serializeRef(this.#ref);
     }
     get refItem() {
         return this.#ref;
     }
+    get json() {
+        return this.#shape;
+    }
     getObjectSchema() {
         if (!this.#dereferencedSchema) {
             this.#dereferencedSchema = this.#refResolver.dereferenceSchema(this.#shape.schema);

package/dist/refs.d.ts

@@ -1,21 +1,21 @@
 import { type Maybe } from '@takeshape/util';
 import type { AIToolConfig, Args, ObjectSchema, ProjectSchemaJSON, PropertySchema, QueryJSON, Ref, ReturnShape, ShapeJSON, ShapeSchema } from './project-schema/index.ts';
-import type { SchemaPath, SchemaWithRef } from './types/index.ts';
+import type { SchemaPath } from './types/index.ts';
 export type ServicesContext = Pick<ProjectSchemaJSON, 'services'>;
 export type ServicesShapesContext = Pick<ProjectSchemaJSON, 'services' | 'shapes'>;
+export declare const LOCAL_LAYER_ID = "local";
 /**
  * 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;
+    shapeName: string;
+    layerId: string;
     template?: string;
-    isForeign: boolean;
-    isValidService: boolean;
-    isInterfaceRef?: boolean;
+};
+export type PropertyRefItem = RefItem & {
+    propertyName: string;
 };
 /**
  * Adds a schema path, needed when visiting a whole schema to report errors.
@@ -23,10 +23,6 @@ export type RefItem = {
 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.
  */
@@ -40,7 +36,7 @@ export type ParsedReturnShape = {
     shapeName: string;
     ref?: RefItem;
 };
-export declare function parseReturnShape(projectSchema: ServicesContext, shape: ReturnShape): ParsedReturnShape;
+export declare function parseReturnShape(context: ServicesContext, shape: ReturnShape): ParsedReturnShape;
 /**
  * Convert Query.shape to a PropertySchema
  */
@@ -55,8 +51,7 @@ export declare function createTemplateShapeName(template: string, shapeName: str
  */
 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[];
+export declare function refSchemaToPath(context: ServicesContext, refSchema: PropertySchema): string[];
 /**
  * Safely turn a "template" shape reference (`@args`, `args`, `shape`) into a `RefItem`
  *
@@ -65,7 +60,8 @@ export declare function refSchemaToPath(context: ServicesContext, refSchema: Sch
  * 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;
+export declare function parseRef(context: ServicesContext, refExpression: string): RefItem;
+export declare function isRefEqual(context: ServicesContext, a: string | RefItem, b: string | RefItem): boolean;
 /**
  * Converts a list of ref expressions into a list of ref items.
  */
@@ -79,24 +75,12 @@ export declare function refExpressionListToRefItemList(context: ServicesContext,
  * 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 getShapeByRef(context: ServicesShapesContext, refExpression: string): Maybe<ShapeJSON>;
+export declare function isValidServiceId(context: ServicesContext, serviceId: string): boolean;
+export declare function isValidRefItem(context: ServicesContext): (refItem: RefItem) => boolean;
 export declare function refToRefItem(context: ServicesContext, $ref: string, template?: string): RefItem;
 export type ParsedName = {
-    namespace?: string;
-    serviceId: string;
+    layerId: string;
     name: string;
 };
 /**
@@ -109,14 +93,14 @@ export declare function shapeToRefString(context: ServicesContext, shape: ShapeJ
  * 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>;
+export declare function getRef(context: ServicesContext, refSchema: PropertySchema): Maybe<RefItem>;
+export declare function getRefWithPath(context: ServicesContext, refSchema: PropertySchema, schemaPath?: SchemaPath): 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;
+export declare function hasRefProperty(schema: PropertySchema): boolean;
 /**
  * From a property that has oneOf or items with oneOf, get all refs
  */
@@ -125,19 +109,20 @@ export declare function getOneOfRefs(context: ServicesContext, propertySchema: P
  * 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>;
+export declare function getRefOrItemsRef(context: ServicesContext, refSchema: PropertySchema, schemaPath?: SchemaPath): Maybe<RefItemWithPath>;
 /**
  * Turns a `RefItem` into an `@ref`.
  */
-export declare function refItemToAtRef(refItem: RefItem): string;
+export declare function serializeRef(refItem: RefItem): string;
 /**
  * Turns a `RefItem` into a standard shape name, namespacing if present.
  */
-export declare function refItemToNamespacedShapeName(refItem: RefItem): string;
+export declare function refItemToNamespacedShapeName(context: ServicesContext, refItem: RefItem): string;
+export declare function refExpressionToNamespacedName(context: ServicesContext, refExpression: string): string;
 /**
  * Turns a `RefItem` into a path suitable for `lodash.get`.
  */
-export declare function refItemToShapePath(refItem: RefItem): string[];
+export declare function refItemToShapePath(context: ServicesContext, refItem: RefItem): string[];
 /**
  * Get a Shape referenced by a `RefItem`.
  */
@@ -160,11 +145,11 @@ export declare function refItemToShapeSchema(context: ServicesShapesContext, ref
 /**
  * Sugar, for when you really just need a string...
  */
-export declare function getRefShapeName(context: ServicesContext, refSchema: SchemaWithRef): Maybe<string>;
+export declare function getRefShapeName(context: ServicesContext, refSchema: PropertySchema): Maybe<string>;
 /**
  * Sugar, for when you really just need a path...
  */
-export declare function anyRefToShapeSchemaPath(context: ServicesContext, refSchema: SchemaWithRef): Maybe<string[]>;
+export declare function refSchemaToShapeSchemaPath(context: ServicesContext, refSchema: PropertySchema): Maybe<string[]>;
 /**
  * Helper fn to omit `ref` props from the target schema, and then extend it with the source schema.
  */
@@ -192,23 +177,16 @@ export declare function hasResolvableRef(context: ServicesShapesContext, schema:
  */
 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 type GetNamespace = (layerId: 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 serializePropertyRef({ shapeName, propertyName, layerId }: 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 formatShapeRef(layerId: 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>;
 /**
@@ -224,7 +202,8 @@ export type QueryEntry = {
 };
 export declare function getQuery(projectSchema: Pick<ProjectSchemaJSON, 'services' | 'shapes' | 'queries' | 'mutations'>, queryRef: string): Maybe<QueryEntry>;
 export declare function ensureQuery(projectSchema: ProjectSchemaJSON, queryRef: string): QueryEntry;
-export declare function normalizeRefs(projectSchema: ProjectSchemaJSON, property: PropertySchema): PropertySchema;
+export declare function normalizeRefs(projectSchema: ProjectSchemaJSON): ProjectSchemaJSON;
+export declare function normalizeRefs(projectSchema: ProjectSchemaJSON, property?: PropertySchema): PropertySchema;
 /**
  * Get a ShapeJSON from a RefItem, with the schema dereferenced.
  */