@tinacms/cli 1.0.4 → 1.0.6

package/dist/cmds/forestry-migrate/index.d.ts

@@ -0,0 +1,17 @@
+/**
+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 { TinaCloudCollection } from '@tinacms/schema-tools';
+export declare const generateCollections: ({ forestryPath, rootPath, }: {
+    forestryPath: string;
+    rootPath: string;
+}) => Promise<TinaCloudCollection<false>[]>;

package/dist/cmds/forestry-migrate/util/index.d.ts

@@ -0,0 +1,144 @@
+/**
+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 type { TinaFieldInner } from '@tinacms/schema-tools';
+declare const forestryFieldWithoutField: z.ZodObject<{
+    type: z.ZodUnion<[z.ZodLiteral<"text">, z.ZodLiteral<"datetime">, z.ZodLiteral<"list">, z.ZodLiteral<"file">, z.ZodLiteral<"image_gallery">, z.ZodLiteral<"textarea">, z.ZodLiteral<"tag_list">, z.ZodLiteral<"number">, z.ZodLiteral<"boolean">, z.ZodLiteral<"field_group">, z.ZodLiteral<"field_group_list">, z.ZodLiteral<"select">, z.ZodLiteral<"include">, z.ZodLiteral<"blocks">, z.ZodLiteral<"color">]>;
+    name: z.ZodString;
+    label: z.ZodString;
+    default: z.ZodOptional<z.ZodAny>;
+    config: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        use_select: z.ZodOptional<z.ZodBoolean>;
+        date_format: z.ZodOptional<z.ZodString>;
+        time_format: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        source: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"custom">, z.ZodLiteral<"pages">, z.ZodLiteral<"documents">, z.ZodLiteral<"simple">, z.ZodString]>>;
+            section: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: string;
+            section?: string;
+        }, {
+            type?: string;
+            section?: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        required?: boolean;
+        options?: string[];
+        use_select?: boolean;
+        date_format?: string;
+        time_format?: string;
+        source?: {
+            type?: string;
+            section?: string;
+        };
+    }, {
+        required?: boolean;
+        options?: string[];
+        use_select?: boolean;
+        date_format?: string;
+        time_format?: string;
+        source?: {
+            type?: string;
+            section?: string;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    default?: any;
+    label?: string;
+    config?: {
+        required?: boolean;
+        options?: string[];
+        use_select?: boolean;
+        date_format?: string;
+        time_format?: string;
+        source?: {
+            type?: string;
+            section?: string;
+        };
+    };
+    name?: string;
+    type?: "number" | "boolean" | "file" | "datetime" | "text" | "list" | "select" | "image_gallery" | "textarea" | "tag_list" | "field_group" | "field_group_list" | "include" | "blocks" | "color";
+}, {
+    default?: any;
+    label?: string;
+    config?: {
+        required?: boolean;
+        options?: string[];
+        use_select?: boolean;
+        date_format?: string;
+        time_format?: string;
+        source?: {
+            type?: string;
+            section?: string;
+        };
+    };
+    name?: string;
+    type?: "number" | "boolean" | "file" | "datetime" | "text" | "list" | "select" | "image_gallery" | "textarea" | "tag_list" | "field_group" | "field_group_list" | "include" | "blocks" | "color";
+}>;
+declare type ForestryFieldWithoutFieldType = z.infer<typeof forestryFieldWithoutField>;
+interface ForestryFieldType extends ForestryFieldWithoutFieldType {
+    fields?: ForestryFieldType[];
+}
+declare const FrontmatterTemplateSchema: z.ZodObject<{
+    label: z.ZodString;
+    hide_body: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodType<ForestryFieldType, z.ZodTypeDef, ForestryFieldType>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    label?: string;
+    fields?: ForestryFieldType[];
+    hide_body?: boolean;
+}, {
+    label?: string;
+    fields?: ForestryFieldType[];
+    hide_body?: boolean;
+}>;
+export declare const transformForestryFieldsToTinaFields: ({ fields, collection, }: {
+    fields: z.infer<typeof FrontmatterTemplateSchema>['fields'];
+    collection: string;
+}) => TinaFieldInner<false>[];
+export declare const getFieldsFromTemplates: ({ tem, rootPath, collection, }: {
+    tem: string;
+    collection: string;
+    rootPath: string;
+}) => TinaFieldInner<false>[];
+export declare const parseTemplates: ({ val }: {
+    val: unknown;
+}) => {
+    label?: string;
+    fields?: ForestryFieldType[];
+    hide_body?: boolean;
+};
+export declare const hasForestryConfig: ({ rootPath }: {
+    rootPath: string;
+}) => Promise<{
+    path: string;
+    exists: boolean;
+}>;
+export declare const parseSections: ({ val }: {
+    val: unknown;
+}) => {
+    sections?: {
+        label?: string;
+        path?: string;
+        type?: "directory" | "document" | "heading" | "jekyll-pages" | "jekyll-posts";
+        match?: string;
+        exclude?: string;
+        create?: "documents" | "all" | "none";
+        templates?: string[];
+        new_doc_ext?: string;
+        read_only?: boolean;
+    }[];
+};
+export {};

package/dist/cmds/init/index.d.ts

@@ -1,4 +1,17 @@
+export interface Framework {
+    name: 'next' | 'hugo' | 'jekyll' | 'other';
+    reactive: boolean;
+}
 export declare function initStaticTina(ctx: any, next: () => void, options: any): Promise<void>;
+export interface AddConfigArgs {
+    publicFolder: string;
+    baseDir: string;
+    usingTypescript: boolean;
+    framework: Framework;
+    collections?: string;
+    token?: string;
+    clientId?: string;
+}
 /**
  * Executes a shell command and return it as a Promise.
  * @param cmd {string}

package/dist/cmds/init/setup-files/config.d.ts

@@ -10,9 +10,9 @@ 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 { AddConfigArgs, Framework } from '..';
+declare type Keys = Framework['name'];
 export declare const configExamples: {
-    next: () => string;
-    other: (args: {
-        publicFolder: string;
-    }) => string;
+    [key in Keys]: (args?: AddConfigArgs) => string;
 };
+export {};

package/dist/index.js

@@ -302,7 +302,7 @@ var commander = __toModule(require("commander"));
 
 // package.json
 var name = "@tinacms/cli";
-var version = "1.0.4";
+var version = "1.0.6";
 
 // src/cmds/audit/audit.ts
 var import_graphql = __toModule(require("@tinacms/graphql"));
@@ -626,9 +626,9 @@ var fileExists = ({
   }
   const filePaths = allowedTypes.map((ext) => import_path2.default.join(projectDir, `${filename}.${ext}`));
   let inputFile = void 0;
-  filePaths.every((path9) => {
-    if (import_fs_extra.default.existsSync(path9)) {
-      inputFile = path9;
+  filePaths.every((path10) => {
+    if (import_fs_extra.default.existsSync(path10)) {
+      inputFile = path10;
       return false;
     }
     return true;
@@ -646,9 +646,9 @@ var getPath = ({
   }
   const filePaths = allowedTypes.map((ext) => import_path2.default.join(projectDir, `${filename}.${ext}`));
   let inputFile = void 0;
-  filePaths.every((path9) => {
-    if (import_fs_extra.default.existsSync(path9)) {
-      inputFile = path9;
+  filePaths.every((path10) => {
+    if (import_fs_extra.default.existsSync(path10)) {
+      inputFile = path10;
       return false;
     }
     return true;
@@ -1391,13 +1391,14 @@ var buildAdmin = async ({
   var _a;
   if ((_a = schema == null ? void 0 : schema.config) == null ? void 0 : _a.build) {
     const buildVite = async () => {
-      var _a2, _b, _c, _d;
+      var _a2, _b, _c, _d, _e, _f, _g;
       await (0, import_app.viteBuild)({
         local,
         rootPath: rootPath2,
         outputFolder: (_b = (_a2 = schema == null ? void 0 : schema.config) == null ? void 0 : _a2.build) == null ? void 0 : _b.outputFolder,
         publicFolder: (_d = (_c = schema == null ? void 0 : schema.config) == null ? void 0 : _c.build) == null ? void 0 : _d.publicFolder,
-        apiUrl
+        apiUrl,
+        host: (_g = (_f = (_e = schema == null ? void 0 : schema.config) == null ? void 0 : _e.build) == null ? void 0 : _f.host) != null ? _g : false
       });
     };
     if (local) {
@@ -1727,8 +1728,9 @@ stack: ${code.stack || "No stack was provided"}`);
 };
 
 // src/cmds/init/index.ts
-var import_path12 = __toModule(require("path"));
-var import_fs_extra8 = __toModule(require("fs-extra"));
+var import_path13 = __toModule(require("path"));
+var import_prettier = __toModule(require("prettier"));
+var import_fs_extra10 = __toModule(require("fs-extra"));
 var import_prompts2 = __toModule(require("prompts"));
 var import_metrics3 = __toModule(require("@tinacms/metrics"));
 
@@ -1966,28 +1968,76 @@ function extendNextScripts(scripts) {
 }
 
 // src/cmds/init/setup-files/config.ts
+var other = (args) => {
+  return `
+import { defineConfig } from "tinacms";
+
+// Your hosting provider likely exposes this as an environment variable
+const branch = process.env.HEAD || process.env.VERCEL_GIT_COMMIT_REF || "main";
+
+export default defineConfig({
+  branch,
+  clientId: ${args.clientId ? `'${args.clientId}'` : "null"}, // Get this from tina.io
+  token:  ${args.token ? `'${args.token}'` : "null"}, // Get this from tina.io
+  build: {
+    outputFolder: "admin",
+    publicFolder: "${args.publicFolder}",
+  },
+  media: {
+    tina: {
+      mediaRoot: "",
+      publicFolder: "${args.publicFolder}",
+    },
+  },
+  schema: {
+    collections: ${args.collections || `[
+      {
+        name: "post",
+        label: "Posts",
+        path: "content/posts",
+        fields: [
+          {
+            type: "string",
+            name: "title",
+            label: "Title",
+            isTitle: true,
+            required: true,
+          },
+          {
+            type: "rich-text",
+            name: "body",
+            label: "Body",
+            isBody: true,
+          },
+        ],
+      },
+    ]`},
+  },
+});
+`;
+};
 var configExamples = {
-  next: () => `import { defineConfig } from 'tinacms'
+  next: (args) => `import { defineConfig } from 'tinacms'
 
   // Your hosting provider likely exposes this as an environment variable
   const branch = process.env.HEAD || process.env.VERCEL_GIT_COMMIT_REF || 'main'
   
   export default defineConfig({
     branch,
-    clientId: null, // Get this from tina.io
-    token: null, // Get this from tina.io
+    clientId: ${args.clientId ? `'${args.clientId}'` : "null"}, // Get this from tina.io
+    token:  ${args.token ? `'${args.token}'` : "null"}, // Get this from tina.io
     build: {
-      outputFolder: 'admin',
-      publicFolder: 'public',
+      outputFolder: "admin",
+      publicFolder: "${args.publicFolder}",
     },
     media: {
       tina: {
-        mediaRoot: 'uploads',
-        publicFolder: 'public',
+        mediaRoot: "",
+        publicFolder: "${args.publicFolder}",
       },
     },
     schema: {
-      collections: [
+      collections:${args.collections || `[
         {
           name: 'post',
           label: 'Posts',
@@ -2012,74 +2062,387 @@ var configExamples = {
             router: ({ document }) => \`/demo/blog/\${document._sys.filename}\`,
           },
         },
-      ],
+      ]`},
     },
   })
   `,
-  other: (args) => {
-    return `
-  import { defineConfig } from "tinacms";
-  
-  // Your hosting provider likely exposes this as an environment variable
-  const branch = process.env.HEAD || process.env.VERCEL_GIT_COMMIT_REF || "main";
-  
-  export default defineConfig({
-    branch,
-    clientId: null,   // Get this from tina.io
-    token: null,      // Get this from tina.io
-    build: {
-      outputFolder: "admin",
-      publicFolder: "${args.publicFolder}",
-    },
-    media: {
-      tina: {
-        mediaRoot: "uploads",
-        publicFolder: "${args.publicFolder}",
-      },
-    },
-    schema: {
-      collections: [
-        {
-          name: "post",
-          label: "Posts",
-          path: "content/posts",
-          fields: [
-            {
-              type: "string",
-              name: "title",
-              label: "Title",
-              isTitle: true,
-              required: true,
-            },
-            {
-              type: "rich-text",
-              name: "body",
-              label: "Body",
-              isBody: true,
-            },
-          ],
-        },
-      ],
-    },
+  other,
+  hugo: other,
+  jekyll: other
+};
+
+// src/cmds/forestry-migrate/util/index.ts
+var import_fs_extra8 = __toModule(require("fs-extra"));
+var import_path12 = __toModule(require("path"));
+var import_js_yaml = __toModule(require("js-yaml"));
+var import_zod = __toModule(require("zod"));
+var forestryConfigSchema = import_zod.default.object({
+  sections: import_zod.default.array(import_zod.default.object({
+    type: import_zod.default.union([
+      import_zod.default.literal("directory"),
+      import_zod.default.literal("document"),
+      import_zod.default.literal("heading"),
+      import_zod.default.literal("jekyll-pages"),
+      import_zod.default.literal("jekyll-posts")
+    ]),
+    label: import_zod.default.string(),
+    path: import_zod.default.string().optional(),
+    match: import_zod.default.string().optional(),
+    exclude: import_zod.default.string().optional(),
+    create: import_zod.default.union([import_zod.default.literal("all"), import_zod.default.literal("documents"), import_zod.default.literal("none")]).optional(),
+    templates: import_zod.default.array(import_zod.default.string()).optional(),
+    new_doc_ext: import_zod.default.string().optional(),
+    read_only: import_zod.default.boolean().optional()
+  }))
+});
+var forestryFieldWithoutField = import_zod.default.object({
+  type: import_zod.default.union([
+    import_zod.default.literal("text"),
+    import_zod.default.literal("datetime"),
+    import_zod.default.literal("list"),
+    import_zod.default.literal("file"),
+    import_zod.default.literal("image_gallery"),
+    import_zod.default.literal("textarea"),
+    import_zod.default.literal("tag_list"),
+    import_zod.default.literal("number"),
+    import_zod.default.literal("boolean"),
+    import_zod.default.literal("field_group"),
+    import_zod.default.literal("field_group_list"),
+    import_zod.default.literal("select"),
+    import_zod.default.literal("include"),
+    import_zod.default.literal("blocks"),
+    import_zod.default.literal("color")
+  ]),
+  name: import_zod.default.string(),
+  label: import_zod.default.string(),
+  default: import_zod.default.any().optional(),
+  config: import_zod.default.object({
+    required: import_zod.default.boolean().optional(),
+    use_select: import_zod.default.boolean().optional(),
+    date_format: import_zod.default.string().optional(),
+    time_format: import_zod.default.string().optional(),
+    options: import_zod.default.array(import_zod.default.string()).optional(),
+    source: import_zod.default.object({
+      type: import_zod.default.union([
+        import_zod.default.literal("custom"),
+        import_zod.default.literal("pages"),
+        import_zod.default.literal("documents"),
+        import_zod.default.literal("simple"),
+        import_zod.default.string()
+      ]).optional(),
+      section: import_zod.default.string().optional()
+    }).optional()
+  }).optional()
+});
+var forestryField = import_zod.default.lazy(() => forestryFieldWithoutField.extend({
+  fields: import_zod.default.array(forestryField).optional()
+}));
+var FrontmatterTemplateSchema = import_zod.default.object({
+  label: import_zod.default.string(),
+  hide_body: import_zod.default.boolean().optional(),
+  fields: import_zod.default.array(forestryField).optional()
+});
+var transformForestryFieldsToTinaFields = ({
+  fields,
+  collection
+}) => {
+  const tinaFields = [];
+  fields == null ? void 0 : fields.forEach((forestryField2) => {
+    var _a, _b, _c, _d;
+    let field;
+    switch (forestryField2.type) {
+      case "text":
+        field = {
+          type: "string",
+          name: forestryField2.name,
+          label: forestryField2.label
+        };
+        break;
+      case "textarea":
+        field = {
+          type: "string",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          ui: {
+            component: "textarea"
+          }
+        };
+        break;
+      case "datetime":
+        field = {
+          type: forestryField2.type,
+          name: forestryField2.name,
+          label: forestryField2.label
+        };
+        break;
+      case "number":
+        field = {
+          type: "number",
+          name: forestryField2.name,
+          label: forestryField2.label
+        };
+        break;
+      case "boolean":
+        field = {
+          type: "boolean",
+          name: forestryField2.name,
+          label: forestryField2.label
+        };
+        break;
+      case "color":
+        field = {
+          type: "string",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          ui: {
+            component: "color"
+          }
+        };
+        break;
+      case "file":
+        field = {
+          type: "image",
+          name: forestryField2.name || "image",
+          label: forestryField2.label
+        };
+        break;
+      case "select":
+        if ((_a = forestryField2.config) == null ? void 0 : _a.options) {
+          field = {
+            type: "string",
+            name: forestryField2.name,
+            label: forestryField2.label,
+            options: ((_b = forestryField2.config) == null ? void 0 : _b.options) || []
+          };
+        } else {
+          logger.info(`Warning in collection ${collection}. "select" field migration has only been implemented for simple select. Other versions of select have not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`);
+        }
+        break;
+      case "list":
+        field = {
+          type: "string",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          list: true
+        };
+        if ((_c = forestryField2.config) == null ? void 0 : _c.options) {
+          field.options = forestryField2.config.options;
+        }
+        break;
+      case "tag_list":
+        field = {
+          type: "string",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          list: true,
+          ui: {
+            component: "tags"
+          }
+        };
+        break;
+      case "field_group":
+        field = {
+          type: "object",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          fields: transformForestryFieldsToTinaFields({
+            fields: forestryField2.fields,
+            collection
+          })
+        };
+        break;
+      case "field_group_list":
+        field = {
+          type: "object",
+          name: forestryField2.name,
+          label: forestryField2.label,
+          list: true,
+          fields: transformForestryFieldsToTinaFields({
+            fields: forestryField2.fields,
+            collection
+          })
+        };
+        break;
+      case "image_gallery":
+      case "include":
+        console.log(`Unsupported field type: ${forestryField2.type}, in collection ${collection}. This will not be added to the schema.`);
+        break;
+      default:
+        logger.info(`Warning in collection ${collection}. "${forestryField2.type}" migration has not been implemented yet. To make your \`${forestryField2.name}\` field work, you will need to manually add it to your schema.`);
+    }
+    if (field) {
+      if ((_d = forestryField2.config) == null ? void 0 : _d.required) {
+        field = __spreadProps(__spreadValues({}, field), { required: true });
+      }
+      tinaFields.push(field);
+    }
   });
-  `;
+  return tinaFields;
+};
+var getFieldsFromTemplates = ({
+  tem,
+  rootPath: rootPath2,
+  collection
+}) => {
+  const templatePath = import_path12.default.join(rootPath2, ".forestry", "front_matter", "templates", `${tem}.yml`);
+  let templateString = "";
+  try {
+    templateString = import_fs_extra8.default.readFileSync(templatePath).toString();
+  } catch {
+    throw new Error(`Could not find template ${tem} at ${templatePath}
+
+ This will require manual migration.`);
   }
+  const templateObj = import_js_yaml.default.load(templateString);
+  const template = parseTemplates({ val: templateObj });
+  const fields = transformForestryFieldsToTinaFields({
+    fields: template.fields,
+    collection
+  });
+  return fields;
+};
+var parseTemplates = ({ val }) => {
+  const template = FrontmatterTemplateSchema.parse(val);
+  return template;
+};
+var hasForestryConfig = async ({ rootPath: rootPath2 }) => {
+  const forestryPath = import_path12.default.join(rootPath2, ".forestry", "settings.yml");
+  const exists = await import_fs_extra8.default.pathExists(forestryPath);
+  return {
+    path: forestryPath,
+    exists
+  };
+};
+var parseSections = ({ val }) => {
+  const schema = forestryConfigSchema.parse(val);
+  return schema;
+};
+
+// src/cmds/forestry-migrate/index.ts
+var import_fs_extra9 = __toModule(require("fs-extra"));
+var import_js_yaml2 = __toModule(require("js-yaml"));
+var stringifyLabel = (label) => {
+  return label.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+};
+var generateCollections = async ({
+  forestryPath,
+  rootPath: rootPath2
+}) => {
+  var _a;
+  const forestryConfig = await import_fs_extra9.default.readFile(forestryPath);
+  const forestryYaml = import_js_yaml2.default.load(forestryConfig.toString());
+  const forestrySchema = parseSections({ val: forestryYaml });
+  const collections = [];
+  (_a = forestrySchema.sections) == null ? void 0 : _a.forEach((section) => {
+    var _a2, _b;
+    if (section.read_only)
+      return;
+    switch (section.type) {
+      case "directory":
+        const fields = [
+          {
+            type: "rich-text",
+            name: "body",
+            label: "Body of Document",
+            description: "This is the markdown body",
+            isBody: true
+          }
+        ];
+        if ((((_a2 = section.templates) == null ? void 0 : _a2.length) || 0) > 1) {
+          const templates = [];
+          section.templates.forEach((tem) => {
+            try {
+              const fields2 = getFieldsFromTemplates({
+                tem,
+                collection: stringifyLabel(section.label),
+                rootPath: rootPath2
+              });
+              templates.push({ fields: fields2, label: tem, name: stringifyLabel(tem) });
+            } catch (e) {
+              console.log("Error parsing template ", tem);
+              console.error(e);
+            }
+          });
+          const c = {
+            label: section.label,
+            name: stringifyLabel(section.label),
+            path: section.path,
+            templates
+          };
+          if ((section == null ? void 0 : section.create) === "none") {
+            c.ui = __spreadProps(__spreadValues({}, c.ui), {
+              allowedActions: {
+                create: false
+              }
+            });
+          }
+          collections.push(c);
+        } else {
+          (_b = section.templates) == null ? void 0 : _b.forEach((tem) => {
+            try {
+              const additionalFields = getFieldsFromTemplates({
+                tem,
+                rootPath: rootPath2,
+                collection: stringifyLabel(section.label)
+              });
+              fields.push(...additionalFields);
+            } catch (e) {
+              console.log("Error parsing template ", tem);
+              console.error(e);
+            }
+          });
+          const c = {
+            label: section.label,
+            name: stringifyLabel(section.label),
+            path: section.path,
+            fields
+          };
+          if ((section == null ? void 0 : section.create) === "none") {
+            c.ui = __spreadProps(__spreadValues({}, c.ui), {
+              allowedActions: {
+                create: false
+              }
+            });
+          }
+          collections.push(c);
+        }
+        break;
+    }
+  });
+  return collections;
 };
 
 // src/cmds/init/index.ts
 async function initStaticTina(ctx, next, options) {
   const baseDir = ctx.rootPath;
   logger.level = "info";
+  const clientId = await chooseClientId();
+  let token = null;
+  if (clientId) {
+    token = await chooseToken({ clientId });
+  }
   const packageManager = await choosePackageManager();
   const framework = await chooseFramework();
   const usingTypescript = await chooseTypescript();
   const publicFolder = await choosePublicFolder({ framework });
-  await reportTelemetry(usingTypescript, options.noTelemetry);
-  const hasPackageJSON = await import_fs_extra8.default.pathExistsSync("package.json");
+  const forestryPath = await hasForestryConfig({ rootPath: ctx.rootPath });
+  let collections;
+  if (forestryPath.exists) {
+    collections = await forestryMigrate({
+      forestryPath: forestryPath.path,
+      rootPath: ctx.rootPath
+    });
+  }
+  await reportTelemetry({
+    usingTypescript,
+    hasForestryConfig: forestryPath.exists,
+    noTelemetry: options.noTelemetry
+  });
+  const hasPackageJSON = await import_fs_extra10.default.pathExistsSync("package.json");
   if (!hasPackageJSON) {
     await createPackageJSON();
   }
-  const hasGitignore = await import_fs_extra8.default.pathExistsSync(".gitignore");
+  const hasGitignore = await import_fs_extra10.default.pathExistsSync(".gitignore");
   if (!hasGitignore) {
     await createGitignore({ baseDir });
   } else {
@@ -2091,8 +2454,18 @@ async function initStaticTina(ctx, next, options) {
     }
   }
   await addDependencies(packageManager);
-  await addConfigFile({ publicFolder, baseDir, usingTypescript, framework });
-  await addContentFile({ baseDir });
+  await addConfigFile({
+    publicFolder,
+    baseDir,
+    usingTypescript,
+    framework,
+    collections,
+    token,
+    clientId
+  });
+  if (!forestryPath.exists) {
+    await addContentFile({ baseDir });
+  }
   if (framework.reactive) {
     await addReactiveFile[framework.name]({
       baseDir,
@@ -2102,6 +2475,24 @@ async function initStaticTina(ctx, next, options) {
   }
   logNextSteps({ packageManager, framework });
 }
+var chooseClientId = async () => {
+  const option = await (0, import_prompts2.default)({
+    name: "clientId",
+    type: "text",
+    message: `What is your Tina Cloud Client ID? (Hit enter to skip and set up yourself later)
+${logText("Don't have a Client ID? Create one here: ")}${linkText("https://app.tina.io/projects/new")}`
+  });
+  return option["clientId"];
+};
+var chooseToken = async ({ clientId }) => {
+  const option = await (0, import_prompts2.default)({
+    name: "token",
+    type: "text",
+    message: `What is your Tina Cloud Read Only Token?
+${logText("Don't have a Read Only Token? Create one here: ")}${linkText(`https://app.tina.io/projects/${clientId}/tokens`)}`
+  });
+  return option["token"];
+};
 var choosePackageManager = async () => {
   const option = await (0, import_prompts2.default)({
     name: "selection",
@@ -2125,15 +2516,23 @@ var chooseTypescript = async () => {
   return option["selection"];
 };
 var choosePublicFolder = async ({ framework }) => {
-  if (framework.name === "next") {
-    return "public";
+  let suggestion = "public";
+  switch (framework.name) {
+    case "next":
+      return "public";
+    case "hugo":
+      return "static";
+    case "jekyll":
+      suggestion = "public";
+      break;
   }
   const option = await (0, import_prompts2.default)({
     name: "selection",
     type: "text",
-    message: 'Where are public assets stored? (default: "public")'
+    message: `Where are public assets stored? (default: "${suggestion}")
+Not sure what value to use? Refer to our "Frameworks" doc: https://tina.io/docs/integration/frameworks/`
   });
-  return option["selection"] || "public";
+  return option["selection"] || suggestion;
 };
 var chooseFramework = async () => {
   const option = await (0, import_prompts2.default)({
@@ -2142,15 +2541,43 @@ var chooseFramework = async () => {
     message: "What framework are you using?",
     choices: [
       { title: "Next.js", value: { name: "next", reactive: true } },
+      { title: "Hugo", value: { name: "hugo", reactive: false } },
+      { title: "Jekyll", value: { name: "jekyll", reactive: false } },
       {
-        title: "Other (SSG frameworks like hugo, jekyll, etc.)",
+        title: "Other (SSG frameworks like gatsby, etc.)",
         value: { name: "other", reactive: false }
       }
     ]
   });
   return option["selection"];
 };
-var reportTelemetry = async (usingTypescript, noTelemetry) => {
+var forestryMigrate = async ({
+  forestryPath,
+  rootPath: rootPath2
+}) => {
+  logger.info(`It looks like you have a ${focusText(".forestry/settings.yml")} file in your project.`);
+  const option = await (0, import_prompts2.default)({
+    name: "selection",
+    type: "confirm",
+    initial: true,
+    message: `Please note that this is a beta version and may contain some issues
+Would you like to migrate your Forestry templates?
+${logText("Note: This migration will not be perfect, but it will get you started.")}`
+  });
+  if (!option["selection"]) {
+    return null;
+  }
+  const collections = await generateCollections({
+    forestryPath,
+    rootPath: rootPath2
+  });
+  return JSON.stringify(collections, null, 2);
+};
+var reportTelemetry = async ({
+  hasForestryConfig: hasForestryConfig2,
+  noTelemetry,
+  usingTypescript
+}) => {
   if (noTelemetry) {
     logger.info(logText("Telemetry disabled"));
   }
@@ -2159,7 +2586,8 @@ var reportTelemetry = async (usingTypescript, noTelemetry) => {
   await telemetry.submitRecord({
     event: {
       name: "tinacms:cli:init:invoke",
-      schemaFileType: schemaFileType2
+      schemaFileType: schemaFileType2,
+      hasForestryConfig: hasForestryConfig2
     }
   });
 };
@@ -2169,22 +2597,22 @@ var createPackageJSON = async () => {
 };
 var createGitignore = async ({ baseDir }) => {
   logger.info(logText("No .gitignore found, creating one"));
-  await import_fs_extra8.default.outputFileSync(import_path12.default.join(baseDir, ".gitignore"), "node_modules");
+  await import_fs_extra10.default.outputFileSync(import_path13.default.join(baseDir, ".gitignore"), "node_modules");
 };
 var checkGitignoreForNodeModules = async ({
   baseDir
 }) => {
-  const gitignoreContent = await import_fs_extra8.default.readFileSync(import_path12.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path13.default.join(baseDir, ".gitignore")).toString();
   return gitignoreContent.split("\n").some((item) => item === "node_modules");
 };
 var addNodeModulesToGitignore = async ({ baseDir }) => {
   logger.info(logText("Adding node_modules to .gitignore"));
-  const gitignoreContent = await import_fs_extra8.default.readFileSync(import_path12.default.join(baseDir, ".gitignore")).toString();
+  const gitignoreContent = await import_fs_extra10.default.readFileSync(import_path13.default.join(baseDir, ".gitignore")).toString();
   const newGitignoreContent = [
     ...gitignoreContent.split("\n"),
     "node_modules"
   ].join("\n");
-  await import_fs_extra8.default.writeFileSync(import_path12.default.join(baseDir, ".gitignore"), newGitignoreContent);
+  await import_fs_extra10.default.writeFileSync(import_path13.default.join(baseDir, ".gitignore"), newGitignoreContent);
 };
 var addDependencies = async (packageManager) => {
   logger.info(logText("Adding dependencies, this might take a moment..."));
@@ -2197,15 +2625,11 @@ var addDependencies = async (packageManager) => {
   logger.info(indentedCmd(`${logText(packageManagers[packageManager])}`));
   await execShellCommand(packageManagers[packageManager]);
 };
-var addConfigFile = async ({
-  framework,
-  baseDir,
-  publicFolder,
-  usingTypescript
-}) => {
-  const configPath = import_path12.default.join(".tina", `config.${usingTypescript ? "ts" : "js"}`);
-  const fullConfigPath = import_path12.default.join(baseDir, configPath);
-  if (import_fs_extra8.default.pathExistsSync(fullConfigPath)) {
+var addConfigFile = async (args) => {
+  const { baseDir, usingTypescript } = args;
+  const configPath = import_path13.default.join(".tina", `config.${usingTypescript ? "ts" : "js"}`);
+  const fullConfigPath = import_path13.default.join(baseDir, configPath);
+  if (import_fs_extra10.default.pathExistsSync(fullConfigPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
       type: "confirm",
@@ -2213,19 +2637,19 @@ var addConfigFile = async ({
     });
     if (override["selection"]) {
       logger.info(logText(`Overriding file at ${configPath}.`));
-      await import_fs_extra8.default.outputFileSync(fullConfigPath, config({ publicFolder, framework }));
+      await import_fs_extra10.default.outputFileSync(fullConfigPath, config(args));
     } else {
       logger.info(logText(`Not overriding file at ${configPath}.`));
     }
   } else {
     logger.info(logText(`Adding config file at .tina/config.${usingTypescript ? "ts" : "js"}`));
-    await import_fs_extra8.default.outputFileSync(fullConfigPath, config({ publicFolder, framework }));
+    await import_fs_extra10.default.outputFileSync(fullConfigPath, config(args));
   }
 };
 var addContentFile = async ({ baseDir }) => {
-  const contentPath = import_path12.default.join("content", "posts", "hello-world.md");
-  const fullContentPath = import_path12.default.join(baseDir, contentPath);
-  if (import_fs_extra8.default.pathExistsSync(fullContentPath)) {
+  const contentPath = import_path13.default.join("content", "posts", "hello-world.md");
+  const fullContentPath = import_path13.default.join(baseDir, contentPath);
+  if (import_fs_extra10.default.pathExistsSync(fullContentPath)) {
     const override = await (0, import_prompts2.default)({
       name: "selection",
       type: "confirm",
@@ -2233,13 +2657,13 @@ var addContentFile = async ({ baseDir }) => {
     });
     if (override["selection"]) {
       logger.info(logText(`Overriding file at ${contentPath}.`));
-      await import_fs_extra8.default.outputFileSync(fullContentPath, content);
+      await import_fs_extra10.default.outputFileSync(fullContentPath, content);
     } else {
       logger.info(logText(`Not overriding file at ${contentPath}.`));
     }
   } else {
     logger.info(logText(`Adding content file at ${contentPath}`));
-    await import_fs_extra8.default.outputFileSync(fullContentPath, content);
+    await import_fs_extra10.default.outputFileSync(fullContentPath, content);
   }
 };
 var logNextSteps = ({
@@ -2252,16 +2676,19 @@ ${titleText(" TinaCMS ")} has been initialized!`));
   logger.info(`
 Once your site is running, access the CMS at ${linkText("<YourDevURL>/admin/index.html")}`);
 };
+var other2 = ({ packageManager }) => {
+  const packageManagers = {
+    pnpm: `pnpm`,
+    npm: `npx`,
+    yarn: `yarn`
+  };
+  const installText = `${packageManagers[packageManager]} tinacms dev -c "<your dev command>"`;
+  return installText;
+};
 var frameworkDevCmds = {
-  other: ({ packageManager }) => {
-    const packageManagers = {
-      pnpm: `pnpm`,
-      npm: `npx`,
-      yarn: `yarn`
-    };
-    const installText = `${packageManagers[packageManager]} tinacms dev -c "<your dev command>"`;
-    return installText;
-  },
+  other: other2,
+  hugo: other2,
+  jekyll: other2,
   next: ({ packageManager }) => {
     const packageManagers = {
       pnpm: `pnpm`,
@@ -2273,7 +2700,7 @@ var frameworkDevCmds = {
   }
 };
 var config = (args) => {
-  return configExamples[args.framework.name](args);
+  return (0, import_prettier.format)(configExamples[args.framework.name](args));
 };
 var content = `---
 title: Hello, World!
@@ -2290,22 +2717,22 @@ var addReactiveFile = {
     baseDir,
     usingTypescript
   }) => {
-    const usingSrc = !import_fs_extra8.default.pathExistsSync(import_path12.default.join(baseDir, "pages"));
-    const pagesPath = import_path12.default.join(baseDir, usingSrc ? "src" : "", "pages");
-    const packageJSONPath = import_path12.default.join(baseDir, "package.json");
-    const tinaBlogPagePath = import_path12.default.join(pagesPath, "demo", "blog");
-    const tinaBlogPagePathFile = import_path12.default.join(tinaBlogPagePath, `[filename].${usingTypescript ? "tsx" : "js"}`);
-    if (!import_fs_extra8.default.pathExistsSync(tinaBlogPagePathFile)) {
-      import_fs_extra8.default.mkdirpSync(tinaBlogPagePath);
-      import_fs_extra8.default.writeFileSync(tinaBlogPagePathFile, nextPostPage({ usingSrc }));
+    const usingSrc = !import_fs_extra10.default.pathExistsSync(import_path13.default.join(baseDir, "pages"));
+    const pagesPath = import_path13.default.join(baseDir, usingSrc ? "src" : "", "pages");
+    const packageJSONPath = import_path13.default.join(baseDir, "package.json");
+    const tinaBlogPagePath = import_path13.default.join(pagesPath, "demo", "blog");
+    const tinaBlogPagePathFile = import_path13.default.join(tinaBlogPagePath, `[filename].${usingTypescript ? "tsx" : "js"}`);
+    if (!import_fs_extra10.default.pathExistsSync(tinaBlogPagePathFile)) {
+      import_fs_extra10.default.mkdirpSync(tinaBlogPagePath);
+      import_fs_extra10.default.writeFileSync(tinaBlogPagePathFile, nextPostPage({ usingSrc }));
     }
     logger.info("Adding a nextjs example... \u2705");
-    const pack = JSON.parse(import_fs_extra8.default.readFileSync(packageJSONPath).toString());
+    const pack = JSON.parse(import_fs_extra10.default.readFileSync(packageJSONPath).toString());
     const oldScripts = pack.scripts || {};
     const newPack = JSON.stringify(__spreadProps(__spreadValues({}, pack), {
       scripts: extendNextScripts(oldScripts)
     }), null, 2);
-    import_fs_extra8.default.writeFileSync(packageJSONPath, newPack);
+    import_fs_extra10.default.writeFileSync(packageJSONPath, newPack);
   }
 };
 function execShellCommand(cmd) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinacms/cli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -21,7 +21,7 @@
     ]
   },
   "devDependencies": {
-    "@tinacms/scripts": "1.0.0",
+    "@tinacms/scripts": "1.0.1",
     "@types/clear": "0.1.0",
     "@types/cli-spinner": "^0.2.1",
     "@types/cors": "2.8.5",
@@ -52,11 +52,11 @@
     "@graphql-codegen/visitor-plugin-common": "^2.4.0",
     "@graphql-tools/graphql-file-loader": "^7.2.0",
     "@graphql-tools/load": "^7.3.2",
-    "@tinacms/app": "1.0.3",
+    "@tinacms/app": "1.0.4",
     "@tinacms/datalayer": "1.0.0",
-    "@tinacms/graphql": "1.0.3",
-    "@tinacms/metrics": "1.0.0",
-    "@tinacms/schema-tools": "1.0.3",
+    "@tinacms/graphql": "1.0.5",
+    "@tinacms/metrics": "1.0.1",
+    "@tinacms/schema-tools": "1.2.0",
     "add": "^2.0.6",
     "ajv": "^6.12.3",
     "altair-express-middleware": "4.0.6",
@@ -82,10 +82,12 @@
     "multer": "1.4.5-lts.1",
     "normalize-path": "^3.0.0",
     "url-pattern": "^1.0.3",
+    "prettier": "^2.2.1",
     "progress": "^2.0.3",
     "prompts": "^2.4.1",
     "yarn": "^1.22.17",
-    "yup": "^0.32.9"
+    "yup": "^0.32.9",
+    "zod": "^3.14.3"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"