@tinacms/schema-tools 0.1.8 → 0.2.0

package/dist/index.es.js

@@ -263,12 +263,23 @@ class TinaSchema {
             assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
             return value.map((item) => {
               const { _template, ...rest } = item;
-              return { [_template]: rest };
+              const template = field.templates.find((template2) => {
+                if (typeof template2 === "string") {
+                  return false;
+                }
+                return template2.name === _template;
+              });
+              if (typeof template === "string") {
+                throw new Error("Global templates not supported");
+              }
+              return {
+                [_template]: this.transformCollectablePayload(rest, template)
+              };
             });
           } else {
             assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
             const { _template, ...rest } = value;
-            return { [_template]: rest };
+            return { [_template]: this.transformCollectablePayload(rest, field) };
           }
         } else {
           return value;
@@ -813,10 +824,10 @@ class TinaSchemaValidationError extends Error {
   }
 }
 const validateSchema = ({
-  config
+  schema
 }) => {
   try {
-    TinaCloudSchemaZod.parse(config);
+    TinaCloudSchemaZod.parse(schema);
   } catch (e) {
     if (e instanceof ZodError) {
       const errors = parseZodError({ zodError: e });

package/dist/index.js

@@ -290,12 +290,23 @@
               assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
               return value.map((item) => {
                 const { _template, ...rest } = item;
-                return { [_template]: rest };
+                const template = field.templates.find((template2) => {
+                  if (typeof template2 === "string") {
+                    return false;
+                  }
+                  return template2.name === _template;
+                });
+                if (typeof template === "string") {
+                  throw new Error("Global templates not supported");
+                }
+                return {
+                  [_template]: this.transformCollectablePayload(rest, template)
+                };
               });
             } else {
               assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
               const { _template, ...rest } = value;
-              return { [_template]: rest };
+              return { [_template]: this.transformCollectablePayload(rest, field) };
             }
           } else {
             return value;
@@ -840,10 +851,10 @@ ${JSON.stringify(val, null, 2)}
     }
   }
   const validateSchema = ({
-    config
+    schema
   }) => {
     try {
-      TinaCloudSchemaZod.parse(config);
+      TinaCloudSchemaZod.parse(schema);
     } catch (e) {
       if (e instanceof z.ZodError) {
         const errors = parseZodError({ zodError: e });

package/dist/types/SchemaTypes.d.ts

@@ -28,6 +28,9 @@ export declare type UIField<F extends UIField = any, Shape = any> = {
 export interface TinaCloudSchema<WithNamespace extends boolean, Store = any> {
     templates?: GlobalTemplate<WithNamespace>[];
     collections: TinaCloudCollection<WithNamespace>[];
+    /**
+     * @deprecated use `defineConfig` in a config.{js,ts} file instead
+     */
     config?: TinaCloudSchemaConfig<Store>;
 }
 export declare type TinaCloudSchemaBase = TinaCloudSchema<false>;
@@ -66,8 +69,23 @@ export declare type TinaIndex = {
     }[];
 };
 export interface UICollection {
+    /**
+     * Customize the way filenames are generated during content creation
+     */
     filename?: {
+        /**
+         * A callback which receives form values as an argument. The return value
+         * here will be used as the filename (the extension is not necessary)
+         *
+         * eg:
+         * ```ts
+         * slugify: (values) => values.title.toLowerCase().split(" ").join("-")
+         * ```
+         */
         slugify?: (values: Record<string, any>) => string;
+        /**
+         * When set to `true`, editors won't be able to modify the filename
+         */
         readonly?: boolean;
     };
     /**
@@ -92,7 +110,7 @@ export interface UICollection {
         collection: TinaCloudCollection<true>;
     }) => string | undefined;
 }
-declare type DefaultItem<ReturnType> = ReturnType | (() => ReturnType);
+export declare type DefaultItem<ReturnType> = ReturnType | (() => ReturnType);
 interface BaseCollection {
     label?: string;
     name: string;
@@ -149,7 +167,7 @@ export interface TinaField {
     ui?: Record<string, any>;
 }
 declare type ScalarType<WithNamespace extends boolean> = WithNamespace extends true ? ScalarTypeWithNamespace : ScalarTypeInner;
-declare type Option = string | {
+export declare type Option = string | {
     label: string;
     value: string;
 };

package/dist/types/schema2.d.ts

@@ -10,4 +10,126 @@ 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 { Option, UICollection } from './SchemaTypes';
+/**
+ * NOTE this is WIP - it's not being used but ideally
+ * we can start to leverage it for the `defineStaticConfig`
+ *
+ * The current schema type defs are way more complex to be
+ * user-facing. This schema also gets rid of stuff we didn't
+ * get around to implementing like `templates: string` (which
+ * were for global templates)
+ *
+ */
+declare type FC<T> = (props: T) => unknown;
+declare type UIField<Type> = {
+    label?: string;
+    description?: string;
+    component?: FC<any> | string | null;
+    parse?: (value: Type, name: string, field: Field) => any;
+    format?: (value: Type, name: string, field: Field) => any;
+    validate?(value: Type, allValues: any, meta: any): Type | undefined | void;
+    /**
+     * @deprecated use `defaultItem` at the collection level instead
+     */
+    defaultValue?: Type;
+};
+declare type FieldGeneric<Type> = {
+    required: true;
+    list: true;
+    ui?: UIField<Type[]>;
+} | {
+    required: true;
+    list?: false | undefined;
+    ui?: UIField<Type>;
+} | {
+    required?: false | undefined;
+    list: true;
+    ui?: UIField<Type[] | undefined>;
+} | {
+    required?: false | undefined;
+    list?: false | undefined;
+    ui?: UIField<Type | undefined>;
+};
+declare type BaseField<Type, Ui extends object = undefined> = {
+    name: string;
+    label?: string;
+    description?: string;
+    ui?: Ui extends object ? UIField<Type> & Ui : UIField<Type>;
+} & FieldGeneric<Type>;
+declare type StringFieldBase = {
+    type: 'string';
+    /** Designate this field's value as the document title  */
+    isTitle?: boolean;
+    options?: Option[];
+} & BaseField<string>;
+declare type StringField = StringFieldBase & FieldGeneric<string>;
+declare type NumberField = {
+    type: 'number';
+} & BaseField<number>;
+declare type BooleanField = {
+    type: 'boolean';
+} & BaseField<boolean>;
+declare type DateTimeField = {
+    type: 'datetime';
+} & BaseField<string>;
+declare type ImageField = {
+    type: 'image';
+} & BaseField<string>;
+declare type ReferenceField = {
+    type: 'reference';
+    collections: string[];
+} & BaseField<string>;
+declare type RichTextField = {
+    type: 'rich-text';
+    /**
+     * For markdown or MDX formats, this value will be
+     * saved to the document body
+     */
+    isBody?: boolean;
+} & BaseField<object> & WithTemplates<true>;
+declare type ObjectField = ({
+    type: 'object';
+} & BaseField<object, {
+    itemProps?(item: Record<string, any>): {
+        key?: string;
+        label?: string;
+    };
+}>) & (WithFields | WithTemplates);
+declare type Field = StringField | NumberField | BooleanField | DateTimeField | ImageField | ReferenceField | RichTextField | ObjectField;
+declare type WithFields = {
+    fields: Field[];
+    templates?: never;
+};
+declare type Template = {
+    name: string;
+    label?: string;
+    fields: Field[];
+    match?: {
+        start: string;
+        end: string;
+    };
+};
+declare type WithTemplates<Optional extends boolean = false> = Optional extends true ? {
+    templates?: Template[];
+    fields?: never;
+} : {
+    templates: Template[];
+    fields?: never;
+};
+declare type TinaCMSCollection = {
+    label?: string;
+    name: string;
+    path: string;
+    format?: 'json' | 'md' | 'markdown' | 'mdx';
+    match?: string;
+    ui?: UICollection;
+} & (WithTemplates | WithFields);
+/**
+ * @deprecated use TinaCMSSchema instead
+ */
+export declare type TinaCloudSchema = TinaCMSSchema;
+export declare type TinaCMSSchema = {
+    collections: TinaCMSCollection[];
+};
 export {};

package/dist/validate/index.d.ts

@@ -15,6 +15,6 @@ export { validateTinaCloudSchemaConfig } from './tinaCloudSchemaConfig';
 export declare class TinaSchemaValidationError extends Error {
     constructor(message: any);
 }
-export declare const validateSchema: ({ config, }: {
-    config: TinaCloudSchema<false>;
+export declare const validateSchema: ({ schema, }: {
+    schema: TinaCloudSchema<false>;
 }) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/schema-tools",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "module": "./dist/index.es.js",
   "exports": {
@@ -23,7 +23,7 @@
     ]
   },
   "devDependencies": {
-    "@tinacms/scripts": "0.51.1",
+    "@tinacms/scripts": "0.51.3",
     "@types/yup": "^0.29.10",
     "jest": "^27.0.6",
     "react": "17.0.2",