feat(schema): _ref and turi management as well as a better working recursive type matching new component signature of core next

Author: Plopix

components/schema/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crystallize/schema",
-    "version": "5.3.0",
+    "version": "6.0.0-beta.0",
     "license": "MIT",
     "exports": {
         "./catalogue": {
@@ -30,7 +30,7 @@
         "test": "vitest run"
     },
     "dependencies": {
-        "zod": "^4.0.15"
+        "zod": "^4.1.12"
     },
     "devDependencies": {
         "@tsconfig/node20": "^20.1.6",

components/schema/src/mass-operation/asset.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { RegisterImageInputSchema } from '../pim';
+import { RefSchema } from '../shared';
+
+export const RegisterImageOperationSchema = RegisterImageInputSchema.extend({
+    intent: z.literal('image/register'),
+    _ref: RefSchema.optional(),
+});
+
+export type RegisterImageOperation = z.infer<typeof RegisterImageOperationSchema>;

components/schema/src/mass-operation/customer.ts

@@ -5,33 +5,40 @@ import {
     CreateCustomerGroupInputSchema,
     UpdateCustomerGroupInputSchema,
 } from '../pim';
+import { RefSchema } from '../shared';
 
 export const CreateCustomerOperationSchema = CreateCustomerInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/create'),
 });
 export type CreateCustomerOperation = z.infer<typeof CreateCustomerOperationSchema>;
 
 export const UpdateCustomerOperationSchema = UpdateCustomerInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/update'),
 });
 export type UpdateCustomerOperation = z.infer<typeof UpdateCustomerOperationSchema>;
 
 export const UpsertCustomerOperationSchema = CreateCustomerInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/upsert'),
 });
 export type UpsertCustomerOperation = z.infer<typeof UpsertCustomerOperationSchema>;
 
 export const CreateCustomerGroupOperationSchema = CreateCustomerGroupInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/group/create'),
 });
 export type CreateCustomerGroupOperation = z.infer<typeof CreateCustomerGroupOperationSchema>;
 
 export const UpdateCustomerGroupOperationSchema = UpdateCustomerGroupInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/group/update'),
 });
 export type UpdateCustomerGroupOperation = z.infer<typeof UpdateCustomerGroupOperationSchema>;
 
 export const UpsertCustomerGroupOperationSchema = CreateCustomerGroupInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('customer/group/upsert'),
 });
 export type UpsertCustomerGroupOperation = z.infer<typeof UpsertCustomerGroupOperationSchema>;

components/schema/src/mass-operation/index.ts

@@ -1,14 +1,5 @@
 import { z } from 'zod';
 
-export const LoopingOperationOperationSchema = z.object({
-    _ref: z.string().optional(),
-});
-
-// Helper function to extend any operation schema with base properties
-export const withLoopingOperationProperties = <T extends z.ZodRawShape>(schema: z.ZodObject<T>) => {
-    return LoopingOperationOperationSchema.extend(schema.shape);
-};
-
 import {
     PublishItemOperationSchema,
     UnPublishItemOperationSchema,
@@ -49,50 +40,53 @@ import {
     UpsertSubscriptionContractOperationSchema,
 } from './subscription-contract.js';
 
+import { RegisterImageOperationSchema } from './asset.js';
+
 export const OperationSchema = z.discriminatedUnion('intent', [
-    withLoopingOperationProperties(CreateDocumentOperationSchema),
-    withLoopingOperationProperties(UpdateDocumentOperationSchema),
-    withLoopingOperationProperties(UpsertDocumentOperationSchema),
+    CreateDocumentOperationSchema,
+    UpdateDocumentOperationSchema,
+    UpsertDocumentOperationSchema,
 
-    withLoopingOperationProperties(CreateFolderOperationSchema),
-    withLoopingOperationProperties(UpdateFolderOperationSchema),
-    withLoopingOperationProperties(UpsertFolderOperationSchema),
+    CreateFolderOperationSchema,
+    UpdateFolderOperationSchema,
+    UpsertFolderOperationSchema,
 
-    withLoopingOperationProperties(CreateProductOperationSchema),
-    withLoopingOperationProperties(UpdateProductOperationSchema),
-    withLoopingOperationProperties(UpsertProductOperationSchema),
+    CreateProductOperationSchema,
+    UpdateProductOperationSchema,
+    UpsertProductOperationSchema,
 
-    withLoopingOperationProperties(PublishItemOperationSchema),
-    withLoopingOperationProperties(UnPublishItemOperationSchema),
+    PublishItemOperationSchema,
+    UnPublishItemOperationSchema,
 
-    withLoopingOperationProperties(UpdateItemComponentOperationSchema),
-    withLoopingOperationProperties(UpdateSkuComponentOperationSchema),
+    UpdateItemComponentOperationSchema,
+    UpdateSkuComponentOperationSchema,
 
-    withLoopingOperationProperties(CreateShapeOperationSchema),
-    withLoopingOperationProperties(UpdateShapeOperationSchema),
-    withLoopingOperationProperties(UpsertShapeOperationSchema),
+    CreateShapeOperationSchema,
+    UpdateShapeOperationSchema,
+    UpsertShapeOperationSchema,
 
-    withLoopingOperationProperties(CreatePieceOperationSchema),
-    withLoopingOperationProperties(UpdatePieceOperationSchema),
-    withLoopingOperationProperties(UpsertPieceOperationSchema),
+    CreatePieceOperationSchema,
+    UpdatePieceOperationSchema,
+    UpsertPieceOperationSchema,
 
-    withLoopingOperationProperties(ModifyProductVariantStockOperationSchema),
+    ModifyProductVariantStockOperationSchema,
+    RegisterImageOperationSchema,
 
-    withLoopingOperationProperties(CreateCustomerGroupOperationSchema),
-    withLoopingOperationProperties(UpdateCustomerGroupOperationSchema),
-    withLoopingOperationProperties(UpsertCustomerGroupOperationSchema),
+    CreateCustomerGroupOperationSchema,
+    UpdateCustomerGroupOperationSchema,
+    UpsertCustomerGroupOperationSchema,
 
-    withLoopingOperationProperties(CreateCustomerOperationSchema),
-    withLoopingOperationProperties(UpdateCustomerOperationSchema),
-    withLoopingOperationProperties(UpsertCustomerOperationSchema),
+    CreateCustomerOperationSchema,
+    UpdateCustomerOperationSchema,
+    UpsertCustomerOperationSchema,
 
-    withLoopingOperationProperties(RegisterOrderOperationSchema),
-    withLoopingOperationProperties(UpdateOrderOperationSchema),
-    withLoopingOperationProperties(UpsertOrderOperationSchema),
+    RegisterOrderOperationSchema,
+    UpdateOrderOperationSchema,
+    UpsertOrderOperationSchema,
 
-    withLoopingOperationProperties(CreateSubscriptionContractOperationSchema),
-    withLoopingOperationProperties(UpdateSubscriptionContractOperationSchema),
-    withLoopingOperationProperties(UpsertSubscriptionContractOperationSchema),
+    CreateSubscriptionContractOperationSchema,
+    UpdateSubscriptionContractOperationSchema,
+    UpsertSubscriptionContractOperationSchema,
 ]);
 
 export const OperationsSchema = z.object({
@@ -146,3 +140,7 @@ export type {
     UpdateSubscriptionContractOperation,
     UpsertSubscriptionContractOperation,
 } from './subscription-contract.js';
+
+export type {
+    RegisterImageOperation
+} from './asset.js';

components/schema/src/mass-operation/item.ts

@@ -8,89 +8,106 @@ import {
     UpdateFolderInputSchema,
     UpdateProductInputSchema,
 } from '../pim/index.js';
-import { IdSchema } from '../shared/index.js';
+import { checkTuriOrId, IdSchema, RefSchema, TURISchema } from '../shared';
 
 export const CreateDocumentOperationSchema = CreateDocumentInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('document/create'),
     language: z.string().min(1),
+    turi: TURISchema.optional(),
 });
 
 export const UpdateDocumentOperationSchema = UpdateDocumentInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('document/update'),
-    itemId: IdSchema,
     language: z.string().min(1),
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+}).superRefine(checkTuriOrId)
 
 export const UpsertDocumentOperationSchema = CreateDocumentInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('document/upsert'),
     language: z.string().min(1),
-    itemId: IdSchema,
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+})
 
 export const CreateFolderOperationSchema = CreateFolderInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('folder/create'),
     language: z.string().min(1),
+    turi: TURISchema.optional(),
 });
 
 export const UpdateFolderOperationSchema = UpdateFolderInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('folder/update'),
     language: z.string().min(1),
-    itemId: IdSchema,
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+}).superRefine(checkTuriOrId)
 
 export const UpsertFolderOperationSchema = CreateFolderInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('folder/upsert'),
     language: z.string().min(1),
-    itemId: IdSchema,
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
 });
 
 export const CreateProductOperationSchema = CreateProductInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('product/create'),
     language: z.string().min(1),
+    turi: TURISchema.optional(),
 });
 
 export const UpdateProductOperationSchema = UpdateProductInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('product/update'),
     language: z.string().min(1),
-    itemId: IdSchema,
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+}).superRefine(checkTuriOrId)
 
 export const UpsertProductOperationSchema = CreateProductInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('product/upsert'),
     language: z.string().min(1),
-    itemId: IdSchema,
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
 });
 
 export const UpdateItemComponentOperationSchema = z.object({
+    _ref: RefSchema.optional(),
     intent: z.literal('item/updateComponent/item'),
     language: z.string().min(1),
     component: ComponentContentInputSchema,
-    sku: z.never().optional(),
-    itemId: IdSchema,
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+}).superRefine(checkTuriOrId)
 
-export const UpdateSkuComponentOperationSchema = UpdateItemComponentOperationSchema.omit({
-    intent: true,
-    itemId: true,
-    sku: true,
-}).extend({
+export const UpdateSkuComponentOperationSchema = z.object({
+    _ref: RefSchema.optional(),
     intent: z.literal('item/updateComponent/sku'),
+    language: z.string().min(1),
+    component: ComponentContentInputSchema,
     sku: z.string(),
-    itemId: z.never().optional(),
 });
 
 export const PublishItemOperationSchema = z.object({
+    _ref: RefSchema.optional(),
     intent: z.literal('item/publish'),
-    itemId: IdSchema,
     language: z.string().min(1),
     includeDescendants: z.boolean().optional(),
-});
+    itemId: IdSchema.optional(),
+    turi: TURISchema.optional(),
+})
 
-export const UnPublishItemOperationSchema = PublishItemOperationSchema.omit({ intent: true }).merge(
-    z.object({
-        intent: z.literal('item/unpublish'),
-    }),
-);
+export const UnPublishItemOperationSchema = PublishItemOperationSchema.omit({ intent: true }).extend({
+    intent: z.literal('item/unpublish')
+})
 
 export type UpdateItemComponentOperation = z.infer<typeof UpdateItemComponentOperationSchema>;
 export type UpdateSkuComponentOperation = z.infer<typeof UpdateSkuComponentOperationSchema>;

components/schema/src/mass-operation/order.ts

@@ -1,20 +1,30 @@
 import { z } from 'zod';
 import { UpdateOrderInputSchema, RegisterOrderInputSchema } from '../pim';
+import { checkTuriOrId, RefSchema, TURISchema } from '../shared';
 
 export const RegisterOrderOperationSchema = RegisterOrderInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('order/register'),
+    turi: TURISchema.optional(),
 });
 export type RegisterOrderOperation = z.infer<typeof RegisterOrderOperationSchema>;
 
-export const UpdateOrderOperationSchema = UpdateOrderInputSchema.extend({
+export const UpdateOrderOperationSchema = UpdateOrderInputSchema.omit({ id: true }).extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('order/update'),
-});
+    id: UpdateOrderInputSchema.shape.id.optional(),
+    turi: TURISchema.optional(),
+}).superRefine(checkTuriOrId)
+
 export type UpdateOrderOperation = z.infer<typeof UpdateOrderOperationSchema>;
 
 export const UpsertOrderOperationSchema = RegisterOrderInputSchema.omit({
     pipelines: true,
 }).extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('order/upsert'),
-    id: UpdateOrderOperationSchema.shape.id.optional(),
+    id: UpdateOrderInputSchema.shape.id.optional(),
+    turi: TURISchema.optional(),
 });
+
 export type UpsertOrderOperation = z.infer<typeof UpsertOrderOperationSchema>;

components/schema/src/mass-operation/product-variant.ts

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { ModifyProductVariantStockInputSchema } from '../pim';
+import { RefSchema } from '../shared';
 
 export const ModifyProductVariantStockOperationSchema = ModifyProductVariantStockInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('product/variant/stock/modify'),
 });
 

components/schema/src/mass-operation/shape.ts

@@ -1,32 +1,39 @@
 import { z } from 'zod';
 import { CreatePieceInputSchema, CreateShapeInputSchema, UpdateShapeInputSchema } from '../pim/shapes/index.js';
+import { RefSchema } from '../shared/index.js';
 
 export const CreateShapeOperationSchema = CreateShapeInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('shape/create'),
 });
 export type CreateShapeOperation = z.infer<typeof CreateShapeOperationSchema>;
 
 export const UpdateShapeOperationSchema = UpdateShapeInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('shape/update'),
 });
 export type UpdateShapeOperation = z.infer<typeof UpdateShapeOperationSchema>;
 
 export const UpsertShapeOperationSchema = CreateShapeOperationSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('shape/upsert'),
 });
 export type UpsertShapeOperation = z.infer<typeof UpsertShapeOperationSchema>;
 
 export const CreatePieceOperationSchema = CreatePieceInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('piece/create'),
 });
 export type CreatePieceOperation = z.infer<typeof CreatePieceOperationSchema>;
 
 export const UpdatePieceOperationSchema = CreatePieceInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('piece/update'),
 });
 export type UpdatePieceOperation = z.infer<typeof UpdatePieceOperationSchema>;
 
 export const UpsertPieceOperationSchema = CreatePieceInputSchema.extend({
+    _ref: RefSchema.optional(),
     intent: z.literal('piece/upsert'),
 });
 export type UpsertPieceOperation = z.infer<typeof UpsertPieceOperationSchema>;