chore(schema): rename turi to resourceIdentifier

Author: Plopix

components/schema/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crystallize/schema",
-    "version": "6.0.0-beta.0",
+    "version": "6.0.0-beta.1",
     "license": "MIT",
     "exports": {
         "./catalogue": {

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

@@ -8,75 +8,75 @@ import {
     UpdateFolderInputSchema,
     UpdateProductInputSchema,
 } from '../pim/index.js';
-import { checkTuriOrId, IdSchema, RefSchema, TURISchema } from '../shared';
+import { checkResourceIdentifierOrId, IdSchema, RefSchema, ResourceIdentifierSchema } from '../shared';
 
 export const CreateDocumentOperationSchema = CreateDocumentInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('document/create'),
     language: z.string().min(1),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const UpdateDocumentOperationSchema = UpdateDocumentInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('document/update'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
-}).superRefine(checkTuriOrId);
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
+}).superRefine(checkResourceIdentifierOrId);
 
 export const UpsertDocumentOperationSchema = CreateDocumentInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('document/upsert'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const CreateFolderOperationSchema = CreateFolderInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('folder/create'),
     language: z.string().min(1),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const UpdateFolderOperationSchema = UpdateFolderInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('folder/update'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
-}).superRefine(checkTuriOrId);
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
+}).superRefine(checkResourceIdentifierOrId);
 
 export const UpsertFolderOperationSchema = CreateFolderInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('folder/upsert'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const CreateProductOperationSchema = CreateProductInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('product/create'),
     language: z.string().min(1),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const UpdateProductOperationSchema = UpdateProductInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('product/update'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
-}).superRefine(checkTuriOrId);
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
+}).superRefine(checkResourceIdentifierOrId);
 
 export const UpsertProductOperationSchema = CreateProductInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('product/upsert'),
     language: z.string().min(1),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const UpdateItemComponentOperationSchema = z
@@ -86,9 +86,9 @@ export const UpdateItemComponentOperationSchema = z
         language: z.string().min(1),
         component: ComponentContentInputSchema,
         itemId: IdSchema.optional(),
-        turi: TURISchema.optional(),
+        resourceIdentifier: ResourceIdentifierSchema.optional(),
     })
-    .superRefine(checkTuriOrId);
+    .superRefine(checkResourceIdentifierOrId);
 
 export const UpdateSkuComponentOperationSchema = z.object({
     _ref: RefSchema.optional(),
@@ -104,7 +104,7 @@ export const PublishItemOperationSchema = z.object({
     language: z.string().min(1),
     includeDescendants: z.boolean().optional(),
     itemId: IdSchema.optional(),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export const UnPublishItemOperationSchema = PublishItemOperationSchema.omit({ intent: true }).extend({

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

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

components/schema/src/mass-operation/subscription-contract.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import { CreateSubscriptionContractInputSchema, UpdateSubscriptionContractInputSchema } from '../pim';
-import { checkTuriOrId, RefSchema, TURISchema } from '../shared';
+import { checkResourceIdentifierOrId, RefSchema, ResourceIdentifierSchema } from '../shared';
 
 export const CreateSubscriptionContractOperationSchema = CreateSubscriptionContractInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('subscription-contract/create'),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 export type CreateSubscriptionContractOperation = z.infer<typeof CreateSubscriptionContractOperationSchema>;
 
@@ -14,17 +14,17 @@ export const UpdateSubscriptionContractOperationSchema = UpdateSubscriptionContr
         _ref: RefSchema.optional(),
         intent: z.literal('subscription-contract/update'),
         id: UpdateSubscriptionContractInputSchema.shape.id.optional(),
-        turi: TURISchema.optional(),
+        resourceIdentifier: ResourceIdentifierSchema.optional(),
     })
-    .superRefine(checkTuriOrId);
+    .superRefine(checkResourceIdentifierOrId);
 
 export type UpdateSubscriptionContractOperation = z.infer<typeof UpdateSubscriptionContractOperationSchema>;
 
 export const UpsertSubscriptionContractOperationSchema = CreateSubscriptionContractInputSchema.extend({
     _ref: RefSchema.optional(),
     intent: z.literal('subscription-contract/upsert'),
     id: UpdateSubscriptionContractInputSchema.shape.id.optional(),
-    turi: TURISchema.optional(),
+    resourceIdentifier: ResourceIdentifierSchema.optional(),
 });
 
 export type UpsertSubscriptionContractOperation = z.infer<typeof UpsertSubscriptionContractOperationSchema>;

components/schema/src/shared/index.ts

@@ -27,18 +27,18 @@ export const KeyValuePairInputSchema = z.object({
 export type KeyValuePair = z.infer<typeof KeyValuePairSchema>;
 export type KeyValuePairInput = z.infer<typeof KeyValuePairInputSchema>;
 
-export const TURISchema = z.string().min(1);
+export const ResourceIdentifierSchema = z.string().min(1);
 export const RefSchema = z.string().min(1);
 
-export const checkTuriOrId = (
-    data: { turi?: string; itemId?: string; id?: string },
+export const checkResourceIdentifierOrId = (
+    data: { resourceIdentifier?: string; itemId?: string; id?: string },
     ctx: { addIssue: ({ code, message, path }: { code: 'custom'; message: string; path: string[] }) => void },
 ) => {
-    if (!data.turi && !(data.itemId || data.id)) {
+    if (!data.resourceIdentifier && !(data.itemId || data.id)) {
         ctx.addIssue({
             code: 'custom',
-            message: 'Expected at least one turi.',
-            path: ['turi'],
+            message: 'Expected at least a resourceIdentifier or an id/itemId.',
+            path: ['resourceIdentifier'],
         });
     }
 };

components/schema/tests/mass-operation/valid-files/file-image.json

@@ -42,7 +42,7 @@
         },
         {
             "intent": "product/upsert",
-            "turi": "product/my-product-with-image-2",
+            "resourceIdentifier": "product/my-product-with-image-2",
             "language": "{{ defaults.languages.[0] }}",
             "shapeIdentifier": "default-product",
             "name": "My Product with Image 2",

components/schema/tests/mass-operation/valid-files/my-first-ever-reusable-package-with-content.json

@@ -114,7 +114,7 @@
         },
         {
             "_ref": "root",
-            "turi": "my-tenant-product-root-folder",
+            "resourceIdentifier": "my-tenant-product-root-folder",
             "intent": "folder/create",
             "name": "Automated folder",
             "language": "en",