@eide/uniformgen 0.1.1 → 0.1.3

package/dist/generators/resolve/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/generators/resolve/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gCAAgC,CAAC;AA6FvF;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,WAAW,EAAE,GACxB,MAAM,CAyMR;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,WAAW,EAAE,GACxB,MAAM,CAwIR;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAoC/E;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAyC/E"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../src/generators/resolve/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gCAAgC,CAAC;AA6FvF;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,WAAW,EAAE,GACxB,MAAM,CAoNR;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,WAAW,EAAE,GACxB,MAAM,CA+IR;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAoC/E;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAyC/E"}

package/dist/generators/resolve/platform.js

@@ -112,6 +112,7 @@ export function generatePlatformResolveReact(model, _allModels) {
     lines.push(` */`);
     lines.push('');
     // Imports
+    lines.push(`import { useMemo } from 'react';`);
     lines.push(`import { useQuery, type QueryHookOptions } from '@apollo/client';`);
     lines.push(`import { gql } from '@apollo/client';`);
     lines.push(`import type { ${dataTypeName} } from '../../types/models/${model.key}.js';`);
@@ -261,12 +262,22 @@ export function generatePlatformResolveReact(model, _allModels) {
     lines.push(`  context?: VariantContext,`);
     lines.push(`  options?: Omit<QueryHookOptions, 'variables'>`);
     lines.push(`) {`);
+    lines.push(`  // Build contexts object from variant context fields`);
+    lines.push(`  // NOTE: Security-sensitive fields (authenticated, customerId, userData) are injected server-side`);
+    lines.push(`  const contexts = useMemo(() => {`);
+    lines.push(`    const ctx: Record<string, unknown> = {};`);
+    lines.push(`    if (context?.device) ctx.device = context.device;`);
+    lines.push(`    if (context?.region) ctx.region = context.region;`);
+    lines.push(`    if (context?.contexts) Object.assign(ctx, context.contexts);`);
+    lines.push(`    return Object.keys(ctx).length > 0 ? ctx : undefined;`);
+    lines.push(`  }, [context?.device, context?.region, context?.contexts]);`);
+    lines.push('');
     lines.push(`  const result = useQuery(RESOLVE_${typeName.toUpperCase()}_QUERY, {`);
     lines.push(`    ...options,`);
     lines.push(`    variables: {`);
     lines.push(`      naturalKey,`);
     lines.push(`      locale: context?.locale,`);
-    lines.push(`      contexts: context?.contexts,`);
+    lines.push(`      contexts,`);
     lines.push(`    },`);
     lines.push(`    skip: !naturalKey,`);
     lines.push(`  });`);
@@ -386,10 +397,17 @@ export function generatePlatformResolveRemix(model, _allModels) {
     lines.push(`  naturalKey: string,`);
     lines.push(`  context?: VariantContext`);
     lines.push(`): Promise<Resolved${typeName} | null> {`);
+    lines.push(`  // Build contexts object from variant context fields`);
+    lines.push(`  // NOTE: Security-sensitive fields (authenticated, customerId, userData) are injected server-side`);
+    lines.push(`  const contexts: Record<string, unknown> = {};`);
+    lines.push(`  if (context?.device) contexts.device = context.device;`);
+    lines.push(`  if (context?.region) contexts.region = context.region;`);
+    lines.push(`  if (context?.contexts) Object.assign(contexts, context.contexts);`);
+    lines.push('');
     lines.push(`  const result = await client.request<{ resolveEntity: any }>(RESOLVE_${typeName.toUpperCase()}_QUERY, {`);
     lines.push(`    naturalKey,`);
     lines.push(`    locale: context?.locale,`);
-    lines.push(`    contexts: context?.contexts,`);
+    lines.push(`    contexts: Object.keys(contexts).length > 0 ? contexts : undefined,`);
     lines.push(`  });`);
     lines.push(`  if (!result.resolveEntity) return null;`);
     lines.push(`  const data = result.resolveEntity;`);

package/dist/generators/types/field-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field-types.d.ts","sourceRoot":"","sources":["../../../src/generators/types/field-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CAmoB/C"}
+{"version":3,"file":"field-types.d.ts","sourceRoot":"","sources":["../../../src/generators/types/field-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CA2oB/C"}

package/dist/generators/types/field-types.js

@@ -219,12 +219,20 @@ export interface SortInput {
  * Used to select the appropriate variant based on user context
  *
  * Context dimensions are configured in the CMS as "context" entities.
- * Common contexts include: device, region, market, customerId, etc.
+ * You can pass common contexts as top-level properties for convenience,
+ * or use the generic \`contexts\` object for custom context dimensions.
+ *
+ * NOTE: Security-sensitive fields (authenticated, customerId, userData) are
+ * injected server-side by middleware and should NOT be passed from the client.
  */
 export interface VariantContext {
   /** Locale code for translation resolution (e.g., 'en-US', 'ja-JP') */
   locale?: string;
-  /** Context dimensions for variant selection (dynamic, configured in CMS) */
+  /** Device type for variant selection (e.g., 'mobile', 'desktop', 'tablet') */
+  device?: string;
+  /** Region for variant selection (e.g., 'us', 'eu', 'apac') */
+  region?: string;
+  /** Generic context dimensions for variant selection (custom contexts configured in CMS) */
   contexts?: Record<string, unknown>;
 }
 

package/dist/graphql/generated/graphql.d.ts

@@ -2746,6 +2746,43 @@ export type EntityReferencesDebug = {
     pages: Array<Scalars['ID']['output']>;
     products: Array<Scalars['ID']['output']>;
 };
+/** Route information for a single entity */
+export type EntityRouteInfo = {
+    __typename?: 'EntityRouteInfo';
+    /**
+     * Child entity routes (only on getEntityRoutes with includeChildren: true).
+     * E.g., products under a collection, pages under a parent page.
+     */
+    children?: Maybe<Array<EntityRouteInfo>>;
+    /** Entity record ID (if found) */
+    entityId?: Maybe<Scalars['ID']['output']>;
+    /** Whether the entity was found */
+    found: Scalars['Boolean']['output'];
+    /** Entity record metadata (badges, labels, flags, etc.) */
+    metadata?: Maybe<Scalars['JSON']['output']>;
+    /** The natural key that was requested */
+    naturalKey: Scalars['String']['output'];
+    /** All routes for this entity across all contexts */
+    routes: Array<EntityRouteWithContext>;
+};
+/** Route with context dimensions */
+export type EntityRouteWithContext = {
+    __typename?: 'EntityRouteWithContext';
+    /** Alias handling strategy if not canonical ('redirect' or 'canonical-tag') */
+    aliasStrategy?: Maybe<Scalars['String']['output']>;
+    /** Canonical path (if this is an alias) */
+    canonicalPath?: Maybe<Scalars['String']['output']>;
+    /**
+     * Context dimensions for this route.
+     * Generic key-value pairs (market, locale, brand, region, etc.)
+     * Empty object means default/global route.
+     */
+    contexts: Scalars['JSON']['output'];
+    /** Whether this is the canonical route for this context */
+    isCanonical: Scalars['Boolean']['output'];
+    /** The full URL path */
+    path: Scalars['String']['output'];
+};
 /** Unified entity search result - works for any entity model */
 export type EntitySearchResult = {
     __typename?: 'EntitySearchResult';
@@ -3429,6 +3466,34 @@ export type GenerateShopifyInstallUrlInput = {
     redirectUri: Scalars['String']['input'];
     shopDomain: Scalars['String']['input'];
 };
+/** Input for batch route lookup */
+export type GetEntitiesRoutesInput = {
+    /** Entity model key */
+    modelKey: Scalars['String']['input'];
+    /** Array of natural keys to look up */
+    naturalKeys: Array<Scalars['String']['input']>;
+};
+/** Result of batch route lookup */
+export type GetEntitiesRoutesResult = {
+    __typename?: 'GetEntitiesRoutesResult';
+    /** Natural keys that were not found */
+    notFound: Array<Scalars['String']['output']>;
+    /** Results in same order as input naturalKeys */
+    results: Array<EntityRouteInfo>;
+};
+/** Input for getting routes for a single entity */
+export type GetEntityRoutesInput = {
+    /** Filter children routes to specific contexts */
+    childContexts?: InputMaybe<Scalars['JSON']['input']>;
+    /** Filter children to specific model key */
+    childModelKey?: InputMaybe<Scalars['String']['input']>;
+    /** Include child entity routes (e.g., products under a collection) */
+    includeChildren?: InputMaybe<Scalars['Boolean']['input']>;
+    /** Entity model key (e.g., 'shopify-product', 'page') */
+    modelKey: Scalars['String']['input'];
+    /** Entity natural key (e.g., product handle, page slug) */
+    naturalKey: Scalars['String']['input'];
+};
 /** Unified global search results */
 export type GlobalSearchResult = {
     __typename?: 'GlobalSearchResult';
@@ -5686,6 +5751,18 @@ export type Query = {
     /** Get frontend URL for sitemap generation */
     frontendUrl?: Maybe<Scalars['String']['output']>;
     getApiKey?: Maybe<ApiKey>;
+    /**
+     * Get routes for multiple entities (batch).
+     * No children - use getEntityRoutes for that.
+     * Optimized for product cards, search results, recommendations.
+     */
+    getEntitiesRoutes: GetEntitiesRoutesResult;
+    /**
+     * Get routes for a single entity with optional children.
+     * Use for collection pages, parent pages, etc.
+     * Children are determined by route tree structure (parentRoute prefix matching).
+     */
+    getEntityRoutes?: Maybe<EntityRouteInfo>;
     /**
      * Global search across all entity records and media.
      *
@@ -5813,8 +5890,8 @@ export type Query = {
     recentlyOpened: Array<RecentlyOpenedItem>;
     /** Get a single redirect by ID */
     redirect?: Maybe<Redirect>;
-    /** List all redirects for the project */
-    redirects: Array<Redirect>;
+    /** List all redirects for the project with pagination */
+    redirects: RedirectsConnection;
     /**
      * Get all repeatable (cron) jobs across all queues.
      * Platform admin only.
@@ -5825,6 +5902,12 @@ export type Query = {
      * Uses headers for project context.
      */
     resolutionDistribution: ResolutionDistribution;
+    /**
+     * Batch resolve entity content by natural key.
+     * Returns full resolved content with variant selection.
+     * Use when you need content with templates, zones, layouts.
+     */
+    resolveEntities: ResolveEntitiesResult;
     /**
      * Resolve entity by model key and natural key (CMS-enriched).
      * Returns full content with templates, zones, layouts, breadcrumbs, gridConfig.
@@ -5896,6 +5979,8 @@ export type Query = {
     tenant?: Maybe<Tenant>;
     tenantBillingStatus: TenantBillingStatusResult;
     tenants: TenantList;
+    /** List unified redirects (manual + route aliases) with pagination */
+    unifiedRedirects: UnifiedRedirectsConnection;
     /**
      * Get unread notification count for badge.
      * Uses headers for user context.
@@ -6164,6 +6249,12 @@ export type QueryFilesArgs = {
 export type QueryGetApiKeyArgs = {
     id: Scalars['ID']['input'];
 };
+export type QueryGetEntitiesRoutesArgs = {
+    input: GetEntitiesRoutesInput;
+};
+export type QueryGetEntityRoutesArgs = {
+    input: GetEntityRoutesInput;
+};
 export type QueryGlobalSearchArgs = {
     includeMedia?: InputMaybe<Scalars['Boolean']['input']>;
     limit?: InputMaybe<Scalars['Int']['input']>;
@@ -6285,11 +6376,15 @@ export type QueryRedirectsArgs = {
     activeOnly?: InputMaybe<Scalars['Boolean']['input']>;
     limit?: InputMaybe<Scalars['Int']['input']>;
     offset?: InputMaybe<Scalars['Int']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
 };
 export type QueryResolutionDistributionArgs = {
     dateRange: DateRangeInput;
     dimension: ResolutionDimension;
 };
+export type QueryResolveEntitiesArgs = {
+    input: ResolveEntitiesInput;
+};
 export type QueryResolveEntityArgs = {
     contexts?: InputMaybe<Scalars['JSON']['input']>;
     includeTemplate?: InputMaybe<Scalars['Boolean']['input']>;
@@ -6374,6 +6469,12 @@ export type QueryTenantsArgs = {
     offset?: InputMaybe<Scalars['Int']['input']>;
     search?: InputMaybe<Scalars['String']['input']>;
 };
+export type QueryUnifiedRedirectsArgs = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<UnifiedRedirectType>;
+};
 export type QueryValidateInvitationArgs = {
     token: Scalars['String']['input'];
 };
@@ -6553,6 +6654,16 @@ export type Redirect = {
     targetPattern: Scalars['String']['output'];
     updatedAt: Scalars['DateTime']['output'];
 };
+/** Connection type for paginated redirects */
+export type RedirectsConnection = {
+    __typename?: 'RedirectsConnection';
+    /** Whether there are more items to fetch */
+    hasMore: Scalars['Boolean']['output'];
+    /** List of redirects */
+    items: Array<Redirect>;
+    /** Total count of redirects matching the filter */
+    total: Scalars['Int']['output'];
+};
 /** Reference resolution options */
 export type ReferenceResolutionOptionsInput = {
     /** Maximum depth for nested resolution (null = unlimited with cycle detection) */
@@ -6680,6 +6791,31 @@ export type ResolutionEvent = {
     path: Scalars['String']['output'];
     timestamp: Scalars['String']['output'];
 };
+/** Input for batch entity content resolution */
+export type ResolveEntitiesInput = {
+    /** Context dimensions for variant resolution */
+    contexts?: InputMaybe<Scalars['JSON']['input']>;
+    /** Include template/zone layout info */
+    includeTemplate?: InputMaybe<Scalars['Boolean']['input']>;
+    /** Locale for field translations */
+    locale?: InputMaybe<Scalars['String']['input']>;
+    /** Entity model key */
+    modelKey: Scalars['String']['input'];
+    /** Array of natural keys to resolve */
+    naturalKeys: Array<Scalars['String']['input']>;
+    /** Reference resolution options */
+    referenceOptions?: InputMaybe<ReferenceResolutionOptionsInput>;
+};
+/** Result of batch entity resolution */
+export type ResolveEntitiesResult = {
+    __typename?: 'ResolveEntitiesResult';
+    /** Natural keys that were not found */
+    notFound: Array<Scalars['String']['output']>;
+    /** Resolution context used */
+    resolvedWith: ResolutionContextOutput;
+    /** Results in same order as input naturalKeys */
+    results: Array<ResolvedEntityBatchResult>;
+};
 export type ResolveNoteInput = {
     noteId: Scalars['ID']['input'];
     resolutionNote?: InputMaybe<Scalars['String']['input']>;
@@ -6703,6 +6839,16 @@ export type ResolvedContent = {
     /** Template reference (null if no template assigned) */
     template?: Maybe<ResolvedTemplateRef>;
 };
+/** Single entity resolution result in batch */
+export type ResolvedEntityBatchResult = {
+    __typename?: 'ResolvedEntityBatchResult';
+    /** Whether the entity was found and resolved */
+    found: Scalars['Boolean']['output'];
+    /** The natural key that was requested */
+    naturalKey: Scalars['String']['output'];
+    /** Full resolution result (same structure as resolveEntity) */
+    resolution?: Maybe<ResolvedEntityContent>;
+};
 /**
  * Resolved entity content (unified output format)
  * Works for ANY entity type - now uses the same structure as public resolveRoute
@@ -7678,6 +7824,55 @@ export type TypographyVariantInput = {
     name: Scalars['String']['input'];
     textTransform?: InputMaybe<Scalars['String']['input']>;
 };
+/** Unified redirect record combining manual redirects and route aliases */
+export type UnifiedRedirect = {
+    __typename?: 'UnifiedRedirect';
+    /** Entity type (route alias only) */
+    entityType?: Maybe<Scalars['String']['output']>;
+    /** Number of times this redirect has been used (manual only) */
+    hitCount?: Maybe<Scalars['Int']['output']>;
+    /** Unique identifier */
+    id: Scalars['ID']['output'];
+    /** Last time this redirect was matched (manual only) */
+    lastHitAt?: Maybe<Scalars['DateTime']['output']>;
+    /** Priority for matching (manual only) */
+    priority?: Maybe<Scalars['Int']['output']>;
+    /** Optional reason/note (manual only) */
+    reason?: Maybe<Scalars['String']['output']>;
+    /** Source URL pattern */
+    source: Scalars['String']['output'];
+    /** HTTP status code */
+    statusCode: Scalars['Int']['output'];
+    /** Target URL pattern */
+    target: Scalars['String']['output'];
+    /** Type of redirect */
+    type: UnifiedRedirectType;
+};
+/** Counts of redirects by type */
+export type UnifiedRedirectCounts = {
+    __typename?: 'UnifiedRedirectCounts';
+    /** Number of manual redirects */
+    manual: Scalars['Int']['output'];
+    /** Number of route aliases */
+    routeAlias: Scalars['Int']['output'];
+};
+/** Type of redirect */
+export declare enum UnifiedRedirectType {
+    Manual = "MANUAL",
+    RouteAlias = "ROUTE_ALIAS"
+}
+/** Connection type for unified redirects with pagination */
+export type UnifiedRedirectsConnection = {
+    __typename?: 'UnifiedRedirectsConnection';
+    /** Counts by type */
+    counts: UnifiedRedirectCounts;
+    /** Whether there are more items */
+    hasMore: Scalars['Boolean']['output'];
+    /** List of unified redirects */
+    items: Array<UnifiedRedirect>;
+    /** Total count matching the filter */
+    total: Scalars['Int']['output'];
+};
 /** Input for unpublishing an entity record variant */
 export type UnpublishEntityRecordVariantInput = {
     variantId: Scalars['ID']['input'];