@tinacms/schema-tools 0.0.2 → 0.0.5

package/CHANGELOG.md

@@ -1,18 +1,37 @@
 # @tinacms/schema-tools
 
+## 0.0.5
+
+### Patch Changes
+
+- f6cb634c2: Added an optional config key to the schema that will be used for tina cloud media store
+
+## 0.0.4
+
+### Patch Changes
+
+- 6e2ed31a2: Added `isTitle` property to the schema that allows the title to be displayed in the CMS
+
+## 0.0.3
+
+### Patch Changes
+
+- 921709a7e: Adds validation to the schema instead of only using typescript types
+
 ## 0.0.2
+
 ### Patch Changes
 
 - abf25c673: The schema can now to used on the frontend (optional for now but will be the main path moving forward).
-  
+
   ### How to migrate.
-  
+
   If you gone though the `tinacms init` process there should be a file called `.tina/components/TinaProvider`. In that file you can import the schema from `schema.ts` and add it to the TinaCMS wrapper component.
-  
+
   ```tsx
   import TinaCMS from 'tinacms'
   import schema, { tinaConfig } from '../schema.ts'
-  
+
   // Importing the TinaProvider directly into your page will cause Tina to be added to the production bundle.
   // Instead, import the tina/provider/index default export to have it dynamially imported in edit-moode
   /**
@@ -26,8 +45,9 @@
       </TinaCMS>
     )
   }
-  
+
   export default TinaProvider
   ```
+
 - 801f39f62: Update types
 - e8b0de1f7: Add `parentTypename` to fields to allow us to disambiguate between fields which have the same field names but different types. Example, an event from field name of `blocks.0.title` could belong to a `Cta` block or a `Hero` block, both of which have a `title` field.

package/dist/index.d.ts

@@ -12,3 +12,4 @@ limitations under the License.
 */
 export * from './schema';
 export * from './types';
+export * from './validate';

package/dist/index.js

@@ -36,8 +36,8 @@ var __objRest = (source, exclude) => {
 };
 var __export = (target, all) => {
   __markAsModule(target);
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 var __reExport = (target, module2, desc) => {
   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
@@ -54,9 +54,12 @@ var __toModule = (module2) => {
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/index.ts
 __export(exports, {
   TinaSchema: () => TinaSchema,
+  TinaSchemaValidationError: () => TinaSchemaValidationError,
   addNamespaceToSchema: () => addNamespaceToSchema,
   resolveField: () => resolveField,
-  resolveForm: () => resolveForm
+  resolveForm: () => resolveForm,
+  validateSchema: () => validateSchema,
+  validateTinaCloudSchemaConfig: () => validateTinaCloudSchemaConfig
 });
 
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/addNamespaceToSchema.ts
@@ -170,10 +173,24 @@ var NAMER = {
   }
 };
 
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/hasDuplicates.ts
+function hasDuplicates(array) {
+  if (!array) {
+    return false;
+  } else {
+    return new Set(array).size !== array.length;
+  }
+}
+
 // pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/schema/TinaSchema.ts
 var TinaSchema = class {
   constructor(config) {
     this.config = config;
+    this.getIsTitleFieldName = (collection) => {
+      const col = this.getCollection(collection);
+      const field = col == null ? void 0 : col.fields.find((x) => x.type === "string" && x.isTitle);
+      return field == null ? void 0 : field.name;
+    };
     this.getCollectionsByName = (collectionNames) => {
       return this.schema.collections.filter((collection) => collectionNames.includes(collection.name));
     };
@@ -445,10 +462,304 @@ var resolveForm = ({
     })
   };
 };
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/index.ts
+var import_zod5 = __toModule(require("zod"));
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/util/parseZodErrors.ts
+var parseZodError = ({ zodError }) => {
+  var _a, _b;
+  const errors = zodError.flatten((issue) => {
+    const moreInfo = [];
+    if (issue.code === "invalid_union") {
+      issue.unionErrors.map((unionError) => {
+        moreInfo.push(parseZodError({ zodError: unionError }));
+      });
+    }
+    const errorMessage = `Error ${issue == null ? void 0 : issue.message} at path ${issue.path.join(".")}`;
+    const errorMessages = [errorMessage, ...moreInfo];
+    return {
+      errors: errorMessages
+    };
+  });
+  const formErrors = errors.formErrors.flatMap((x) => x.errors);
+  const parsedErrors = [
+    ...((_b = (_a = errors.fieldErrors) == null ? void 0 : _a.collections) == null ? void 0 : _b.flatMap((x) => x.errors)) || [],
+    ...formErrors
+  ];
+  return parsedErrors;
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/schema.ts
+var import_zod4 = __toModule(require("zod"));
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/properties.ts
+var import_zod = __toModule(require("zod"));
+var name = import_zod.z.string({
+  required_error: "Name is required but not provided",
+  invalid_type_error: "Name must be a string"
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/fields.ts
+var import_zod2 = __toModule(require("zod"));
+var TypeName = [
+  "string",
+  "boolean",
+  "number",
+  "datetime",
+  "image",
+  "object",
+  "reference",
+  "rich-text"
+];
+var typeTypeError = `type must be one of ${TypeName.join(", ")}`;
+var typeRequiredError = `type is required and must be one of ${TypeName.join(", ")}`;
+var nameProp = import_zod2.z.string({
+  required_error: "name must be provided",
+  invalid_type_error: "name must be a sting"
+});
+var Option = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.object({ label: import_zod2.z.string(), value: import_zod2.z.string() })], {
+  errorMap: () => {
+    return {
+      message: "Invalid option array. Must be a string[] or {label: string, value: string}[]"
+    };
+  }
+});
+var TinaField = import_zod2.z.object({
+  name: nameProp,
+  label: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  required: import_zod2.z.boolean().optional()
+});
+var FieldWithList = TinaField.extend({ list: import_zod2.z.boolean().optional() });
+var TinaScalerBase = FieldWithList.extend({
+  options: import_zod2.z.array(Option).optional()
+});
+var StringField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("string", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  isTitle: import_zod2.z.boolean().optional()
+});
+var BooleanField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("boolean", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var NumberField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("number", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var ImageField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("image", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var DateTimeField = TinaScalerBase.extend({
+  type: import_zod2.z.literal("datetime", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  dateFormat: import_zod2.z.string().optional(),
+  timeFormat: import_zod2.z.string().optional()
+});
+var ReferenceField = FieldWithList.extend({
+  type: import_zod2.z.literal("reference", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+var TinaFieldZod = import_zod2.z.lazy(() => {
+  const TemplateTemp = import_zod2.z.object({
+    label: import_zod2.z.string(),
+    name: nameProp,
+    fields: import_zod2.z.array(TinaFieldZod)
+  }).refine((val) => {
+    var _a;
+    return !hasDuplicates((_a = val.fields) == null ? void 0 : _a.map((x) => x.name));
+  }, {
+    message: "Fields must have a unique name"
+  });
+  const ObjectField = FieldWithList.extend({
+    type: import_zod2.z.literal("object", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    fields: import_zod2.z.array(TinaFieldZod).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Fields must have a unique name"
+    }),
+    templates: import_zod2.z.array(TemplateTemp).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Templates must have a unique name"
+    })
+  });
+  const RichTextField = FieldWithList.extend({
+    type: import_zod2.z.literal("rich-text", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    templates: import_zod2.z.array(TemplateTemp).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+      message: "Templates must have a unique name"
+    })
+  });
+  return import_zod2.z.discriminatedUnion("type", [
+    StringField,
+    BooleanField,
+    NumberField,
+    ImageField,
+    DateTimeField,
+    ReferenceField,
+    ObjectField,
+    RichTextField
+  ], {
+    errorMap: (issue, ctx) => {
+      var _a;
+      if (issue.code === "invalid_union_discriminator") {
+        return {
+          message: `Invalid \`type\` property. In the schema is 'type: ${(_a = ctx.data) == null ? void 0 : _a.type}' and expected one of ${TypeName.join(", ")}`
+        };
+      }
+      return {
+        message: issue.message
+      };
+    }
+  }).superRefine((val, ctx) => {
+    if (val.type === "string") {
+      if (val.isTitle) {
+        if (val.list) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message: "You can not have `list: true` when using `isTitle`"
+          });
+        }
+        if (!val.required) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message: "You must have { required: true } when using `isTitle`"
+          });
+        }
+      }
+    }
+    if (val.type === "object") {
+      const message = "Must provide one of templates or fields in your collection";
+      let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+      if (!isValid) {
+        ctx.addIssue({
+          code: import_zod2.z.ZodIssueCode.custom,
+          message
+        });
+        return false;
+      } else {
+        isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+        if (!isValid) {
+          ctx.addIssue({
+            code: import_zod2.z.ZodIssueCode.custom,
+            message
+          });
+        }
+        return isValid;
+      }
+    }
+    return true;
+  });
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/tinaCloudSchemaConfig.ts
+var import_zod3 = __toModule(require("zod"));
+var tinaConfigKey = import_zod3.default.object({
+  publicFolder: import_zod3.default.string(),
+  syncFolder: import_zod3.default.string()
+}).strict().optional();
+var tinaConfigZod = import_zod3.default.object({
+  media: import_zod3.default.object({
+    tina: tinaConfigKey
+  }).optional()
+});
+var validateTinaCloudSchemaConfig = (config) => {
+  const newConfig = tinaConfigZod.parse(config);
+  return newConfig;
+};
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/schema.ts
+var FORMATS = ["json", "md", "markdown", "mdx"];
+var Template = import_zod4.z.object({
+  label: import_zod4.z.string({
+    invalid_type_error: "label must be a string",
+    required_error: "label was not provided but is required"
+  }),
+  name,
+  fields: import_zod4.z.array(TinaFieldZod)
+}).refine((val) => {
+  var _a;
+  return !hasDuplicates((_a = val.fields) == null ? void 0 : _a.map((x) => x.name));
+}, {
+  message: "Fields must have a unique name"
+});
+var TinaCloudCollectionBase = import_zod4.z.object({
+  label: import_zod4.z.string().optional(),
+  name,
+  format: import_zod4.z.enum(FORMATS).optional()
+});
+var TinaCloudCollection = TinaCloudCollectionBase.extend({
+  fields: import_zod4.z.array(TinaFieldZod).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+    message: "Fields must have a unique name"
+  }).refine((val) => {
+    const arr = (val == null ? void 0 : val.filter((x) => x.type === "string" && x.isTitle)) || [];
+    return arr.length < 2;
+  }, {
+    message: "Fields can only have one use of `isTitle`"
+  }),
+  templates: import_zod4.z.array(Template).min(1).optional().refine((val) => !hasDuplicates(val == null ? void 0 : val.map((x) => x.name)), {
+    message: "Templates must have a unique name"
+  })
+}).refine((val) => {
+  let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+  if (!isValid) {
+    return false;
+  } else {
+    isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+    return isValid;
+  }
+}, { message: "Must provide one of templates or fields in your collection" });
+var TinaCloudSchemaZod = import_zod4.z.object({
+  collections: import_zod4.z.array(TinaCloudCollection),
+  config: tinaConfigZod.optional()
+}).refine((val) => !hasDuplicates(val.collections.map((x) => x.name)), {
+  message: "can not have two collections with the same name"
+});
+
+// pnp:/home/runner/work/tinacms/tinacms/packages/@tinacms/schema-tools/src/validate/index.ts
+var TinaSchemaValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TinaSchemaValidationError";
+  }
+};
+var validateSchema = ({
+  config
+}) => {
+  try {
+    TinaCloudSchemaZod.parse(config);
+  } catch (e) {
+    if (e instanceof import_zod5.ZodError) {
+      const errors = parseZodError({ zodError: e });
+      throw new TinaSchemaValidationError(errors.join(", \n"));
+    } else {
+      throw new Error(e);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TinaSchema,
+  TinaSchemaValidationError,
   addNamespaceToSchema,
   resolveField,
-  resolveForm
+  resolveForm,
+  validateSchema,
+  validateTinaCloudSchemaConfig
 });

package/dist/schema/TinaSchema.d.ts

@@ -41,6 +41,7 @@ export declare class TinaSchema {
         version?: Version;
         meta?: Meta;
     } & TinaCloudSchemaBase);
+    getIsTitleFieldName: (collection: string) => string;
     getCollectionsByName: (collectionNames: string[]) => TinaCloudCollection<true>[];
     getAllCollectionPaths: () => string[];
     getCollection: (collectionName: string) => TinaCloudCollection<true>;

package/dist/types/SchemaTypes.d.ts

@@ -21,9 +21,18 @@ export declare type UIField<F extends UIField = any, Shape = any> = {
     validate?(value: Shape, allValues: any, meta: any, field: UIField<F, Shape>): string | object | undefined | void;
     defaultValue?: Shape;
 };
+export interface TinaCloudSchemaConfig {
+    media?: {
+        tina?: {
+            publicFolder: string;
+            syncFolder: string;
+        };
+    };
+}
 export interface TinaCloudSchema<WithNamespace extends boolean> {
     templates?: GlobalTemplate<WithNamespace>[];
     collections: TinaCloudCollection<WithNamespace>[];
+    config?: TinaCloudSchemaConfig;
 }
 export declare type TinaCloudSchemaBase = TinaCloudSchema<false>;
 export declare type TinaCloudSchemaEnriched = TinaCloudSchema<true>;
@@ -35,6 +44,7 @@ export declare type TinaCloudSchemaEnriched = TinaCloudSchema<true>;
 export interface TinaCloudSchemaWithNamespace {
     templates?: GlobalTemplate<true>[];
     collections: TinaCloudCollection<true>[];
+    config?: TinaCloudSchemaConfig;
     namespace: string[];
 }
 export declare type TinaCloudCollection<WithNamespace extends boolean> = CollectionFields<WithNamespace> | CollectionTemplates<WithNamespace>;
@@ -108,11 +118,13 @@ declare type StringField = {
     type: 'string';
     isBody?: boolean;
     list?: false;
+    isTitle?: boolean;
     ui?: UIField<any, string>;
 } | {
     type: 'string';
     isBody?: boolean;
     list: true;
+    isTitle?: never;
     ui?: UIField<any, string[]>;
 };
 declare type BooleanField = {

package/dist/util/hasDuplicates.d.ts

@@ -0,0 +1,13 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare function hasDuplicates<T = any>(array: T[]): boolean;

package/dist/util/index.d.ts

@@ -14,3 +14,4 @@ export * from './validate';
 export * from './lastItem';
 export * from './namer';
 export * from './sequential';
+export * from './hasDuplicates';

package/dist/util/parseZodErrors.d.ts

@@ -0,0 +1,16 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import type { ZodError } from 'zod';
+export declare const parseZodError: ({ zodError }: {
+    zodError: ZodError;
+}) => string[];

package/dist/util/validate.d.ts

@@ -11,5 +11,5 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import * as yup from 'yup';
-import type { Schema } from 'yup';
-export declare function assertShape<T extends unknown>(value: unknown, yupSchema: (args: typeof yup) => Schema<any, any>, errorMessage?: string): asserts value is T;
+import type { AnySchema } from 'yup';
+export declare function assertShape<T extends unknown>(value: unknown, yupSchema: (args: typeof yup) => AnySchema, errorMessage?: string): asserts value is T;

package/dist/validate/fields.d.ts

@@ -0,0 +1,15 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+import { TinaFieldInner } from '../types/SchemaTypes';
+export declare const TinaFieldZod: z.ZodType<TinaFieldInner<false>>;

package/dist/validate/index.d.ts

@@ -0,0 +1,20 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaCloudSchema } from '../types';
+export { validateTinaCloudSchemaConfig } from './tinaCloudSchemaConfig';
+export declare class TinaSchemaValidationError extends Error {
+    constructor(message: any);
+}
+export declare const validateSchema: ({ config, }: {
+    config: TinaCloudSchema<false>;
+}) => void;

package/dist/validate/properties.d.ts

@@ -0,0 +1,14 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+export declare const name: z.ZodString;

package/dist/validate/schema.d.ts

@@ -0,0 +1,209 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { z } from 'zod';
+export declare const TinaCloudSchemaZod: z.ZodEffects<z.ZodObject<{
+    collections: z.ZodArray<z.ZodEffects<z.ZodObject<z.extendShape<{
+        label: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        format: z.ZodOptional<z.ZodEnum<["json", "md", "markdown", "mdx"]>>;
+    }, {
+        fields: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodType<import("..").TinaFieldInner<false>, z.ZodTypeDef, import("..").TinaFieldInner<false>>, "many">>, import("..").TinaFieldInner<false>[], import("..").TinaFieldInner<false>[]>, import("..").TinaFieldInner<false>[], import("..").TinaFieldInner<false>[]>;
+        templates: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+            label: z.ZodString;
+            name: z.ZodString;
+            fields: z.ZodArray<z.ZodType<import("..").TinaFieldInner<false>, z.ZodTypeDef, import("..").TinaFieldInner<false>>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }>, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }>, "many">>, {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[], {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[]>;
+    }>, "strip", z.ZodTypeAny, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }>, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }, {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }>, "many">;
+    config: z.ZodOptional<z.ZodObject<{
+        media: z.ZodOptional<z.ZodObject<{
+            tina: z.ZodOptional<z.ZodObject<{
+                publicFolder: z.ZodString;
+                syncFolder: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                publicFolder?: string;
+                syncFolder?: string;
+            }, {
+                publicFolder?: string;
+                syncFolder?: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        }, {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    }, {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+    config?: {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    };
+}, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+    config?: {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    };
+}>, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+    config?: {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    };
+}, {
+    collections?: {
+        name?: string;
+        fields?: import("..").TinaFieldInner<false>[];
+        templates?: {
+            name?: string;
+            fields?: import("..").TinaFieldInner<false>[];
+            label?: string;
+        }[];
+        format?: "json" | "md" | "markdown" | "mdx";
+        label?: string;
+    }[];
+    config?: {
+        media?: {
+            tina?: {
+                publicFolder?: string;
+                syncFolder?: string;
+            };
+        };
+    };
+}>;

package/dist/validate/tinaCloudSchemaConfig.d.ts

@@ -0,0 +1,53 @@
+/**
+Copyright 2021 Forestry.io Holdings, Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { TinaCloudSchemaConfig } from '../types';
+import z from 'zod';
+export declare const tinaConfigZod: z.ZodObject<{
+    media: z.ZodOptional<z.ZodObject<{
+        tina: z.ZodOptional<z.ZodObject<{
+            publicFolder: z.ZodString;
+            syncFolder: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            publicFolder?: string;
+            syncFolder?: string;
+        }, {
+            publicFolder?: string;
+            syncFolder?: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        tina?: {
+            publicFolder?: string;
+            syncFolder?: string;
+        };
+    }, {
+        tina?: {
+            publicFolder?: string;
+            syncFolder?: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    media?: {
+        tina?: {
+            publicFolder?: string;
+            syncFolder?: string;
+        };
+    };
+}, {
+    media?: {
+        tina?: {
+            publicFolder?: string;
+            syncFolder?: string;
+        };
+    };
+}>;
+export declare const validateTinaCloudSchemaConfig: (config: unknown) => TinaCloudSchemaConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/schema-tools",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -16,11 +16,12 @@
     ]
   },
   "devDependencies": {
-    "@tinacms/scripts": "0.50.7",
+    "@tinacms/scripts": "0.50.8",
     "@types/yup": "^0.29.10",
     "jest": "^27.0.6",
     "react": "16.14.0",
-    "typescript": "^4.3.5"
+    "typescript": "^4.3.5",
+    "yup": "^0.32.0"
   },
   "peerDependencies": {
     "react": ">=16.14.0",
@@ -39,5 +40,8 @@
   "repository": {
     "url": "https://github.com/tinacms/tinacms.git",
     "directory": "packages/@tinacms/cli"
+  },
+  "dependencies": {
+    "zod": "^3.14.3"
   }
 }