@tinacms/schema-tools 0.1.2 → 0.1.4

package/dist/index.d.ts

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

package/dist/index.es.js

@@ -165,7 +165,7 @@ class TinaSchema {
     };
     this.getCollectionByFullPath = (filepath) => {
       const collection = this.getCollections().find((collection2) => {
-        return filepath.replace("\\", "/").startsWith(collection2.path);
+        return filepath.replace(/\\/g, "/").startsWith(collection2.path.replace(/\/?$/, "/"));
       });
       if (!collection) {
         throw new Error(`Unable to find collection for file at ${filepath}`);
@@ -211,6 +211,72 @@ class TinaSchema {
           return template;
       }
     };
+    this.transformPayload = (collectionName, payload) => {
+      const collection = this.getCollection(collectionName);
+      if (collection.templates) {
+        const template = collection.templates.find((template2) => {
+          if (typeof template2 === "string") {
+            throw new Error("Global templates not supported");
+          }
+          return payload["_template"] === template2.name;
+        });
+        if (!template) {
+          console.error(payload);
+          throw new Error(`Unable to find template for payload`);
+        }
+        if (typeof template === "string") {
+          throw new Error("Global templates not supported");
+        }
+        return {
+          [collectionName]: {
+            [template.name]: this.transformCollectablePayload(payload, template)
+          }
+        };
+      } else {
+        return {
+          [collectionName]: this.transformCollectablePayload(payload, collection)
+        };
+      }
+    };
+    this.transformCollectablePayload = (payload, collection) => {
+      const accumulator = {};
+      Object.entries(payload).forEach(([key, value]) => {
+        if (typeof collection.fields === "string") {
+          throw new Error("Global templates not supported");
+        }
+        const field = collection.fields.find((field2) => {
+          if (typeof field2 === "string") {
+            throw new Error("Global templates not supported");
+          }
+          return field2.name === key;
+        });
+        if (field) {
+          accumulator[key] = this.transformField(field, value);
+        }
+      });
+      return accumulator;
+    };
+    this.transformField = (field, value) => {
+      if (field.type === "object")
+        if (field.templates) {
+          if (field.list) {
+            assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
+            return value.map((item) => {
+              const { _template, ...rest } = item;
+              return { [_template]: rest };
+            });
+          } else {
+            assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
+            const { _template, ...rest } = value;
+            return { [_template]: rest };
+          }
+        } else {
+          return value;
+        }
+      else {
+        return value;
+      }
+    };
     this.isMarkdownCollection = (collectionName) => {
       const collection = this.getCollection(collectionName);
       const format = collection.format;
@@ -261,9 +327,9 @@ class TinaSchema {
     this.schema = config;
   }
 }
-const resolveField = ({ namespace, ...field }, schema) => {
+const resolveField = (field, schema) => {
   var _a;
-  field.parentTypename = NAMER.dataTypeName(namespace.filter((_, i) => i < namespace.length - 1));
+  field.parentTypename = NAMER.dataTypeName(field.namespace.filter((_, i) => i < field.namespace.length - 1));
   const extraFields = field.ui || {};
   switch (field.type) {
     case "number":
@@ -324,10 +390,7 @@ const resolveField = ({ namespace, ...field }, schema) => {
         ...extraFields
       };
     case "object":
-      const templateInfo = schema.getTemplatesForCollectable({
-        ...field,
-        namespace
-      });
+      const templateInfo = schema.getTemplatesForCollectable(field);
       if (templateInfo.type === "object") {
         return {
           ...field,
@@ -345,6 +408,7 @@ const resolveField = ({ namespace, ...field }, schema) => {
           templates2[lastItem(template.namespace)] = {
             label: template.label || templateName,
             key: templateName,
+            namespace: [...field.namespace, templateName],
             fields: template.fields.map((field2) => resolveField(field2, schema)),
             ...extraFields2
           };
@@ -353,6 +417,7 @@ const resolveField = ({ namespace, ...field }, schema) => {
         return {
           ...field,
           typeMap: typeMap2,
+          namespace: field.namespace,
           component: field.list ? "blocks" : "not-implemented",
           templates: templates2,
           ...extraFields
@@ -761,4 +826,4 @@ const validateSchema = ({
     }
   }
 };
-export { TinaSchema, TinaSchemaValidationError, addNamespaceToSchema, resolveField, resolveForm, validateSchema, validateTinaCloudSchemaConfig };
+export { NAMER, TinaSchema, TinaSchemaValidationError, addNamespaceToSchema, resolveField, resolveForm, validateSchema, validateTinaCloudSchemaConfig };

package/dist/index.js

@@ -192,7 +192,7 @@
       };
       this.getCollectionByFullPath = (filepath) => {
         const collection = this.getCollections().find((collection2) => {
-          return filepath.replace("\\", "/").startsWith(collection2.path);
+          return filepath.replace(/\\/g, "/").startsWith(collection2.path.replace(/\/?$/, "/"));
         });
         if (!collection) {
           throw new Error(`Unable to find collection for file at ${filepath}`);
@@ -238,6 +238,72 @@
             return template;
         }
       };
+      this.transformPayload = (collectionName, payload) => {
+        const collection = this.getCollection(collectionName);
+        if (collection.templates) {
+          const template = collection.templates.find((template2) => {
+            if (typeof template2 === "string") {
+              throw new Error("Global templates not supported");
+            }
+            return payload["_template"] === template2.name;
+          });
+          if (!template) {
+            console.error(payload);
+            throw new Error(`Unable to find template for payload`);
+          }
+          if (typeof template === "string") {
+            throw new Error("Global templates not supported");
+          }
+          return {
+            [collectionName]: {
+              [template.name]: this.transformCollectablePayload(payload, template)
+            }
+          };
+        } else {
+          return {
+            [collectionName]: this.transformCollectablePayload(payload, collection)
+          };
+        }
+      };
+      this.transformCollectablePayload = (payload, collection) => {
+        const accumulator = {};
+        Object.entries(payload).forEach(([key, value]) => {
+          if (typeof collection.fields === "string") {
+            throw new Error("Global templates not supported");
+          }
+          const field = collection.fields.find((field2) => {
+            if (typeof field2 === "string") {
+              throw new Error("Global templates not supported");
+            }
+            return field2.name === key;
+          });
+          if (field) {
+            accumulator[key] = this.transformField(field, value);
+          }
+        });
+        return accumulator;
+      };
+      this.transformField = (field, value) => {
+        if (field.type === "object")
+          if (field.templates) {
+            if (field.list) {
+              assertShape(value, (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() })));
+              return value.map((item) => {
+                const { _template, ...rest } = item;
+                return { [_template]: rest };
+              });
+            } else {
+              assertShape(value, (yup2) => yup2.object({ _template: yup2.string().required() }));
+              const { _template, ...rest } = value;
+              return { [_template]: rest };
+            }
+          } else {
+            return value;
+          }
+        else {
+          return value;
+        }
+      };
       this.isMarkdownCollection = (collectionName) => {
         const collection = this.getCollection(collectionName);
         const format = collection.format;
@@ -288,9 +354,9 @@
       this.schema = config;
     }
   }
-  const resolveField = ({ namespace, ...field }, schema) => {
+  const resolveField = (field, schema) => {
     var _a;
-    field.parentTypename = NAMER.dataTypeName(namespace.filter((_, i) => i < namespace.length - 1));
+    field.parentTypename = NAMER.dataTypeName(field.namespace.filter((_, i) => i < field.namespace.length - 1));
     const extraFields = field.ui || {};
     switch (field.type) {
       case "number":
@@ -351,10 +417,7 @@
           ...extraFields
         };
       case "object":
-        const templateInfo = schema.getTemplatesForCollectable({
-          ...field,
-          namespace
-        });
+        const templateInfo = schema.getTemplatesForCollectable(field);
         if (templateInfo.type === "object") {
           return {
             ...field,
@@ -372,6 +435,7 @@
             templates2[lastItem(template.namespace)] = {
               label: template.label || templateName,
               key: templateName,
+              namespace: [...field.namespace, templateName],
               fields: template.fields.map((field2) => resolveField(field2, schema)),
               ...extraFields2
             };
@@ -380,6 +444,7 @@
           return {
             ...field,
             typeMap: typeMap2,
+            namespace: field.namespace,
             component: field.list ? "blocks" : "not-implemented",
             templates: templates2,
             ...extraFields
@@ -788,6 +853,7 @@ ${JSON.stringify(val, null, 2)}
       }
     }
   };
+  exports2.NAMER = NAMER;
   exports2.TinaSchema = TinaSchema;
   exports2.TinaSchemaValidationError = TinaSchemaValidationError;
   exports2.addNamespaceToSchema = addNamespaceToSchema;

package/dist/schema/TinaSchema.d.ts

@@ -64,6 +64,13 @@ export declare class TinaSchema {
         data?: unknown;
         collection: Collectable;
     }) => Templateable;
+    transformPayload: (collectionName: string, payload: object) => {
+        [x: string]: {
+            [x: string]: {};
+        };
+    };
+    private transformCollectablePayload;
+    private transformField;
     isMarkdownCollection: (collectionName: string) => boolean;
     /**
      * Gets the template or templates from the item.

package/dist/schema/resolveField.d.ts

@@ -21,4 +21,9 @@ import { TinaSchema } from './TinaSchema';
  * @param  {TinaSchema} schema the entireT Tina Schema
  * @returns unknown
  */
-export declare const resolveField: ({ namespace, ...field }: TinaFieldEnriched, schema: TinaSchema) => unknown;
+export declare const resolveField: (field: TinaFieldEnriched, schema: TinaSchema) => {
+    [key: string]: unknown;
+    name: string;
+    component: string;
+    type: string;
+};

package/dist/schema/resolveForm.d.ts

@@ -18,5 +18,10 @@ export declare const resolveForm: ({ collection, basename, template, schema, }:
     id: string;
     label: string;
     name: string;
-    fields: unknown[];
+    fields: {
+        [key: string]: unknown;
+        name: string;
+        component: string;
+        type: string;
+    }[];
 };

package/dist/types/SchemaTypes.d.ts

@@ -56,10 +56,17 @@ declare type Document = {
         extension: string;
     };
 };
+export declare type TinaIndex = {
+    name: string;
+    fields: {
+        name: string;
+    }[];
+};
 interface BaseCollection {
     label?: string;
     name: string;
     path: string;
+    indexes?: TinaIndex[];
     format?: FormatType;
     ui?: {
         /**
@@ -117,11 +124,12 @@ export declare type TinaFieldEnriched = TinaFieldInner<true> & {
      */
     parentTypename?: string;
 };
-interface TinaField {
+export interface TinaField {
     name: string;
     label?: string;
     description?: string;
     required?: boolean;
+    indexed?: boolean;
     /**
      * Any items passed to the UI field will be passed to the underlying field.
      * NOTE: only serializable values are supported, so functions like `validate`

package/dist/types/SchemaTypes2.d.ts

@@ -0,0 +1,101 @@
+/**
+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 './SchemaTypes';
+/**
+ * Used with `defineStaticConfig`
+ *
+ * These are mostly similar types as whats in `schemaTypes`
+ * but since those have gone through several iterations
+ * they're pretty messy. These should act as the happy path
+ * for iframe/standalone setups which we hope to eventually
+ * make the default/only path for all Tina users.
+ */
+export declare type TinaCMSConfig<CMSCallback = undefined, FormifyCallback = undefined, DocumentCreatorCallback = undefined, Store = undefined> = {
+    schema: TinaCloudSchema<false>;
+    /**
+     * The base branch to pull content from. Note that this is ignored for local development
+     */
+    branch: string | null;
+    /**
+     * Your clientId from  app.tina.io
+     */
+    clientId: string | null;
+    /**
+     * Your read only token from app.tina.io
+     */
+    token: string | null;
+    /**
+     * Configurations for the autogenerated GraphQL HTTP client
+     */
+    client?: {
+        /**
+         * Autogenerated queries will traverse references to a given depth
+         * @default 2
+         */
+        referenceDepth?: number;
+    };
+    build: {
+        /**
+         * The folder where your application stores assets, eg. `"public"`
+         */
+        publicFolder: string;
+        /**
+         * TinaCMS is shipped as a single-page app, the value specified here will
+         * determine the path when visiting the TinaCMS dashboard.
+         *
+         * Eg. `"admin"` will be viewable at `[your-development-url]/admin/index.html`
+         */
+        outputFolder: string;
+    };
+    media?: {
+        /**
+         * Load a media store like Cloudinary
+         *
+         * ```ts
+         * loadCustomStore = async () => {
+         *   const pack = await import("next-tinacms-cloudinary");
+         *   return pack.TinaCloudCloudinaryMediaStore;
+         * }
+         * ```
+         */
+        loadCustomStore: () => Promise<Store>;
+        tina?: never;
+    } | {
+        /**
+         * Use Git-backed assets for media, these values will
+         * [Learn more](https://tina.io/docs/reference/media/repo-based/)
+         */
+        tina: {
+            /**
+             * The folder where your application stores assets, eg. `"public"`
+             */
+            publicFolder: string;
+            /**
+             * The root folder for media managed by Tina. For example, `"uploads"`
+             * would store content in `"<my-public-folder>/uploads"`
+             */
+            mediaRoot: string;
+        };
+        loadCustomStore?: never;
+    };
+    tinaioConfig?: {
+        assetsApiUrlOverride?: string;
+        frontendUrlOverride?: string;
+        identityApiUrlOverride?: string;
+        contentApiUrlOverride?: string;
+    };
+    cmsCallback?: CMSCallback;
+    formifyCallback?: FormifyCallback;
+    documentCreatorCallback?: DocumentCreatorCallback;
+};
+export {};

package/dist/types/config.d.ts

@@ -37,4 +37,13 @@ export interface TinaCloudSchemaConfig<Store = any> {
             mediaRoot: string;
         };
     };
+    /**
+     * Used to override the default Tina Cloud API URL
+     */
+    tinaioConfig?: {
+        assetsApiUrlOverride?: string;
+        frontendUrlOverride?: string;
+        identityApiUrlOverride?: string;
+        contentApiUrlOverride?: string;
+    };
 }

package/dist/types/index.d.ts

@@ -16,3 +16,4 @@ limitations under the License.
 
 */
 export * from './SchemaTypes';
+export * from './SchemaTypes2';

package/dist/types/schema2.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 {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/schema-tools",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "main": "dist/index.js",
   "module": "./dist/index.es.js",
   "exports": {