@knocklabs/cli 1.1.1 → 1.2.2

package/dist/commands/audience/new.js

@@ -85,7 +85,7 @@ const AUDIENCE_TYPE_CHOICES = [
     },
     {
         name: _audience.AudienceType.Dynamic,
-        message: "Dynamic (rule-based membership) [Beta - requires access]"
+        message: "Dynamic (rule-based membership)"
     }
 ];
 class AudienceNew extends _basecommand.default {
@@ -215,7 +215,7 @@ _define_property(AudienceNew, "flags", {
         char: "k"
     }),
     type: _core.Flags.string({
-        summary: "The type of the audience (static, dynamic). Note: dynamic is in beta and requires access.",
+        summary: "The type of the audience (static, dynamic).",
         char: "t",
         options: [
             _audience.AudienceType.Static,

package/dist/commands/branch/rebase.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return BranchRebase;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _arg = require("../../lib/helpers/arg");
+const _const = require("../../lib/helpers/const");
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class BranchRebase extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        const prompt = `Rebase branch \`${args.slug}\` with main? This updates your branch with the latest changes from main while preserving your branch's commits.`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        const resp = await (0, _request.withSpinner)(()=>this.apiV1.rebaseBranch(args.slug, _const.KnockEnv.Development), {
+            action: "‣ Rebasing branch"
+        });
+        const data = resp.data;
+        if (flags.json) return data;
+        this.render(data);
+    }
+    async render(data) {
+        this.log(`‣ Successfully rebased branch \`${data.slug}\``);
+        this.log(`  Updated at: ${data.updated_at}`);
+    }
+}
+_define_property(BranchRebase, "summary", "Rebases a branch onto the development environment, bringing in changes from main while preserving branch commits.");
+_define_property(BranchRebase, "enableJsonFlag", true);
+_define_property(BranchRebase, "args", {
+    slug: _arg.CustomArgs.slug({
+        required: true,
+        description: "The slug of the branch to rebase"
+    })
+});
+_define_property(BranchRebase, "flags", {
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});

package/dist/commands/commit/index.js

@@ -15,6 +15,7 @@ const _const = require("../../lib/helpers/const");
 const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
 const _request = require("../../lib/helpers/request");
 const _ux = require("../../lib/helpers/ux");
+const _resources = require("../../lib/resources");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -74,24 +75,33 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const ALLOW_EMPTY_RESOURCE_TYPE_SET = new Set(_resources.ALLOW_EMPTY_RESOURCE_TYPES);
 class Commit extends _basecommand.default {
     async run() {
         const { flags } = this.props;
         if (flags["resource-id"] && !flags["resource-type"]) {
             this.error("The --resource-id flag must be used together with --resource-type.");
         }
+        if (flags["allow-empty"]) {
+            if (!flags["resource-type"] || !flags["resource-id"]) {
+                this.error("The --allow-empty flag must be used with a single --resource-type and --resource-id.");
+            }
+            if (!ALLOW_EMPTY_RESOURCE_TYPE_SET.has(flags["resource-type"])) {
+                this.error("Empty commits for `audience` are not yet supported. Other supported resource types: " + _resources.ALLOW_EMPTY_RESOURCE_TYPES.join(", "));
+            }
+        }
         const scope = (0, _command.formatCommandScope)(flags);
         const qualifier = this.formatResourceQualifier(flags);
-        const prompt = qualifier ? `Commit ${qualifier} in the ${scope}?` : `Commit all changes in the ${scope}?`;
+        const prompt = flags["allow-empty"] ? `Create empty commit for ${qualifier} in the ${scope}?` : qualifier ? `Commit ${qualifier} in the ${scope}?` : `Commit all changes in the ${scope}?`;
         const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
         if (!input) return;
         await (0, _request.withSpinner)(()=>this.apiV1.commitAllChanges(this.props));
-        const successMsg = qualifier ? `‣ Successfully committed ${qualifier} in ${scope}` : `‣ Successfully committed all changes in ${scope}`;
+        const successMsg = flags["allow-empty"] ? `‣ Successfully created empty commit for ${qualifier} in ${scope}` : qualifier ? `‣ Successfully committed ${qualifier} in ${scope}` : `‣ Successfully committed all changes in ${scope}`;
         this.log(successMsg);
     }
     formatResourceQualifier(flags) {
         if (flags["resource-type"] && flags["resource-id"]) {
-            return `\`${flags["resource-type"]}\` changes for \`${flags["resource-id"]}\``;
+            return `\`${flags["resource-type"]}\` \`${flags["resource-id"]}\``;
         }
         if (flags["resource-type"]) {
             return `all \`${flags["resource-type"]}\` changes`;
@@ -116,16 +126,10 @@ _define_property(Commit, "flags", {
     force: _core.Flags.boolean({
         summary: "Remove the confirmation prompt."
     }),
+    "allow-empty": _flag.allowEmpty,
     "resource-type": _core.Flags.string({
         summary: "Commit only changes for the given resource type. Can be used alone or together with --resource-id.",
-        options: [
-            "email_layout",
-            "guide",
-            "message_type",
-            "partial",
-            "translation",
-            "workflow"
-        ]
+        options: _resources.ALL_RESOURCE_TYPES
     }),
     "resource-id": _core.Flags.string({
         summary: "Commit only changes for the given resource identifier. Must be used together with --resource-type."

package/dist/commands/commit/list.js

@@ -17,6 +17,7 @@ const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
 const _page = require("../../lib/helpers/page");
 const _request = require("../../lib/helpers/request");
 const _commit = require("../../lib/marshal/commit");
+const _resources = require("../../lib/resources");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -171,14 +172,7 @@ _define_property(CommitList, "flags", {
     "resource-type": _core.Flags.string({
         summary: "Filter commits by resource type. Can be used alone or together with resource-id. Use multiple --resource-type flags for multiple values.",
         multiple: true,
-        options: [
-            "email_layout",
-            "guide",
-            "message_type",
-            "partial",
-            "translation",
-            "workflow"
-        ]
+        options: _resources.ALL_RESOURCE_TYPES
     }),
     "resource-id": _core.Flags.string({
         summary: "Filter commits by resource identifier. Must be used together with resource-type. For most resources, this will be the resource key. In the case of translations, this will be the locale code and namespace, separated by a /. For example, en/courses or en."

package/dist/commands/guide/get.js

@@ -125,6 +125,12 @@ class GuideGet extends _basecommand.default {
                 key: "Description",
                 value: guide.description || "-"
             },
+            {
+                key: "Tags",
+                value: (0, _helpers.formatTags)(guide, {
+                    emptyDisplay: "-"
+                })
+            },
             {
                 key: "Content",
                 value: guide.steps.length > 0 ? (0, _helpers.formatStep)(guide.steps[0]) : "-"

package/dist/commands/guide/list.js

@@ -122,6 +122,12 @@ class GuideList extends _basecommand.default {
                 header: "Description",
                 get: (entry)=>entry.description || "-"
             },
+            tags: {
+                header: "Tags",
+                get: (entry)=>(0, _helpers.formatTags)(entry, {
+                        truncateAfter: 3
+                    })
+            },
             updated_at: {
                 header: "Updated at",
                 get: (entry)=>(0, _date.formatDate)(entry.updated_at)

package/dist/commands/guide/push.js

@@ -163,6 +163,7 @@ _define_property(GuidePush, "flags", {
             "commit"
         ]
     }),
+    "allow-empty": _flag.allowEmptyOnPush,
     force: _flag.force
 });
 _define_property(GuidePush, "args", {

package/dist/commands/layout/push.js

@@ -169,6 +169,7 @@ _define_property(EmailLayoutPush, "flags", {
             "commit"
         ]
     }),
+    "allow-empty": _flag.allowEmptyOnPush,
     force: _flag.force
 });
 _define_property(EmailLayoutPush, "args", {

package/dist/commands/message-type/push.js

@@ -166,6 +166,7 @@ _define_property(MessageTypePush, "flags", {
             "commit"
         ]
     }),
+    "allow-empty": _flag.allowEmptyOnPush,
     force: _flag.force
 });
 _define_property(MessageTypePush, "args", {

package/dist/commands/partial/push.js

@@ -166,6 +166,7 @@ _define_property(PartialPush, "flags", {
             "commit"
         ]
     }),
+    "allow-empty": _flag.allowEmptyOnPush,
     force: _flag.force
 });
 _define_property(PartialPush, "args", {

package/dist/commands/push.js

@@ -113,6 +113,9 @@ class Push extends _basecommand.default {
                 "--commit-message",
                 flags["commit-message"]
             ] : [],
+            ...flags["allow-empty"] ? [
+                "--allow-empty"
+            ] : [],
             ...flags.force ? [
                 "--force"
             ] : []
@@ -151,6 +154,7 @@ _define_property(Push, "flags", {
             "commit"
         ]
     }),
+    "allow-empty": _flag.allowEmptyOnPush,
     force: _flag.force
 });
 const runResourcePushCommand = async (resourceType, targetDirCtx, args)=>{

package/dist/commands/schema/pull.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SchemaPull;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+const _schema = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/schema"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class SchemaPull extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        if (flags.all && args.itemType) {
+            return this.error(`itemType arg \`${args.itemType}\` cannot also be provided when using --all`);
+        }
+        if (flags.all && flags.collection) {
+            return this.error("Flag --collection cannot be provided when using --all");
+        }
+        return flags.all ? this.pullAllSchemas() : this.pullOneSchema();
+    }
+    async pullOneSchema() {
+        const { flags } = this.props;
+        const itemType = this.parseItemType();
+        this.validateCollectionUsage(itemType);
+        const schemasDirCtx = await this.getSchemasDirContext();
+        const schemaFileCtx = await _schema.schemaFileContext(schemasDirCtx.abspath, itemType, flags.collection);
+        if (schemaFileCtx.exists) {
+            const prompt = `Overwrite schema file at ${schemaFileCtx.abspath}?`;
+            const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+            if (!input) return;
+        } else {
+            const prompt = `Create a new schema file at ${schemaFileCtx.abspath}?`;
+            const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+            if (!input) return;
+        }
+        const resp = await (0, _request.withSpinner)(()=>this.apiV1.getSchema(this.props, itemType, flags.collection), {
+            action: "‣ Loading"
+        });
+        if (!resp.data.schema) {
+            _core.ux.error(new _error.ApiError((0, _request.formatErrorRespMessage)(resp)));
+        }
+        await _schema.writeSchemaFileFromData(schemaFileCtx, resp.data.schema);
+        const action = schemaFileCtx.exists ? "updated" : "created";
+        const scope = (0, _command.formatCommandScope)(flags);
+        this.log(`‣ Successfully ${action} schema file at ${schemaFileCtx.abspath} using ${scope}`);
+    }
+    async pullAllSchemas() {
+        const { flags } = this.props;
+        const schemasDirCtx = await this.getSchemasDirContext();
+        const prompt = schemasDirCtx.exists ? `Pull latest schemas into ${schemasDirCtx.abspath}?\n  This will overwrite matching schema files in this directory.` : `Create a new schemas directory at ${schemasDirCtx.abspath}?`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        // Page through the list endpoint so environments with more schemas than a
+        // single page (many object collections) are pulled completely.
+        const schemas = [];
+        let after;
+        do {
+            var _resp_data_entries, _ref;
+            var _resp_data_page_info;
+            // eslint-disable-next-line no-await-in-loop
+            const resp = await (0, _request.withSpinner)(()=>this.apiV1.listSchemas(this.props, {
+                    after
+                }), {
+                action: "‣ Loading"
+            });
+            schemas.push(...(_resp_data_entries = resp.data.entries) !== null && _resp_data_entries !== void 0 ? _resp_data_entries : []);
+            after = (_ref = (_resp_data_page_info = resp.data.page_info) === null || _resp_data_page_info === void 0 ? void 0 : _resp_data_page_info.after) !== null && _ref !== void 0 ? _ref : undefined;
+        }while (after)
+        await _schema.writeSchemasIndexDir(schemasDirCtx.abspath, schemas);
+        const action = schemasDirCtx.exists ? "updated" : "created";
+        const scope = (0, _command.formatCommandScope)(flags);
+        this.log(`‣ Successfully ${action} ${schemas.length} schema file(s) at ${schemasDirCtx.abspath} using ${scope}`);
+    }
+    parseItemType() {
+        const { itemType } = this.props.args;
+        if (!itemType) {
+            return this.error("Missing 1 required arg:\nitemType");
+        }
+        try {
+            return _schema.validateSchemaItemType(itemType);
+        } catch (error) {
+            return this.error(error.message);
+        }
+    }
+    validateCollectionUsage(itemType) {
+        const { collection } = this.props.flags;
+        if (itemType === "object" && !collection) {
+            this.error("Flag --collection is required when itemType is `object`");
+        }
+        if (itemType !== "object" && collection) {
+            this.error("Flag --collection can only be provided for object schemas");
+        }
+        if (itemType === "object" && collection) {
+            try {
+                _schema.validateSchemaCollection(collection);
+            } catch (error) {
+                this.error(error.message);
+            }
+        }
+    }
+    async getSchemasDirContext() {
+        return this.props.flags["schemas-dir"] ? this.props.flags["schemas-dir"] : _schema.resolveSchemasDir(this.projectConfig, this.runContext.cwd);
+    }
+}
+_define_property(SchemaPull, "summary", "Pull one or more item schemas from an environment into a local file system.");
+_define_property(SchemaPull, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    all: _core.Flags.boolean({
+        summary: "Whether to pull all item schemas from the specified environment."
+    }),
+    collection: _core.Flags.string({
+        summary: "The object collection key for object schemas."
+    }),
+    "schemas-dir": _flag.dirPath({
+        summary: "The target schemas directory path."
+    }),
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});
+_define_property(SchemaPull, "args", {
+    itemType: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/schema/push.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SchemaPush;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _command = require("../../lib/helpers/command");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _string = require("../../lib/helpers/string");
+const _schema = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/schema"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class SchemaPush extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        if (flags.all && args.itemType) {
+            return this.error(`itemType arg \`${args.itemType}\` cannot also be provided when using --all`);
+        }
+        if (flags.all && flags.collection) {
+            return this.error("Flag --collection cannot be provided when using --all");
+        }
+        return flags.all ? this.pushAllSchemas() : this.pushOneSchema();
+    }
+    async pushOneSchema() {
+        const { flags } = this.props;
+        const itemType = this.parseItemType();
+        this.validateCollectionUsage(itemType);
+        const schemasDirCtx = await this.getSchemasDirContext();
+        const schemaFileCtx = await _schema.schemaFileContext(schemasDirCtx.abspath, itemType, flags.collection);
+        const [schema, readErrors] = await _schema.readSchemaFile(schemaFileCtx);
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        await this.pushSchema({
+            ...schemaFileCtx,
+            content: this.normalizeSchemaForPush(schema, itemType, flags.collection)
+        });
+        const scope = (0, _command.formatCommandScope)(flags);
+        this.log(`‣ Successfully pushed 1 schema to ${scope}`);
+    }
+    async pushAllSchemas() {
+        const schemasDirCtx = await this.getSchemasDirContext();
+        const [schemas, readErrors] = await _schema.readAllSchemaFiles(schemasDirCtx.abspath);
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        if (schemas.length === 0) {
+            this.error(`No schema files found in ${schemasDirCtx.abspath}`);
+        }
+        for (const schema of schemas){
+            // eslint-disable-next-line no-await-in-loop
+            await this.pushSchema({
+                ...schema,
+                content: this.normalizeSchemaForPush(schema.content, schema.itemType, schema.collection)
+            });
+        }
+        const schemaPaths = schemas.map((schema)=>schema.abspath);
+        const scope = (0, _command.formatCommandScope)(this.props.flags);
+        this.log(`‣ Successfully pushed ${schemas.length} schema file(s) to ${scope}:\n` + (0, _string.indentString)(schemaPaths.join("\n"), 4));
+    }
+    async pushSchema(schema) {
+        try {
+            const resp = await (0, _request.withSpinner)(()=>this.apiV1.upsertSchema(this.props, schema.itemType, schema.content, schema.collection), {
+                action: "‣ Pushing"
+            });
+            if (!resp.data.schema) {
+                throw new Error((0, _request.formatErrorRespMessage)(resp));
+            }
+            await _schema.writeSchemaFileFromData(schema, resp.data.schema);
+        } catch (error) {
+            const sourceError = new _error.SourceError(error.message, schema.abspath, "ApiError");
+            this.error((0, _error.formatError)(sourceError));
+        }
+    }
+    normalizeSchemaForPush(schema, itemType, collection) {
+        return {
+            ...schema,
+            item_type: itemType,
+            item_id: itemType === "object" ? collection : null
+        };
+    }
+    parseItemType() {
+        const { itemType } = this.props.args;
+        if (!itemType) {
+            return this.error("Missing 1 required arg:\nitemType");
+        }
+        try {
+            return _schema.validateSchemaItemType(itemType);
+        } catch (error) {
+            return this.error(error.message);
+        }
+    }
+    validateCollectionUsage(itemType) {
+        const { collection } = this.props.flags;
+        if (itemType === "object" && !collection) {
+            this.error("Flag --collection is required when itemType is `object`");
+        }
+        if (itemType !== "object" && collection) {
+            this.error("Flag --collection can only be provided for object schemas");
+        }
+        if (itemType === "object" && collection) {
+            try {
+                _schema.validateSchemaCollection(collection);
+            } catch (error) {
+                this.error(error.message);
+            }
+        }
+    }
+    async getSchemasDirContext() {
+        return this.props.flags["schemas-dir"] ? this.props.flags["schemas-dir"] : _schema.resolveSchemasDir(this.projectConfig, this.runContext.cwd);
+    }
+}
+_define_property(SchemaPush, "summary", "Push one or more local item schemas to a Knock environment.");
+_define_property(SchemaPush, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    branch: _flag.branch,
+    all: _core.Flags.boolean({
+        summary: "Whether to push all schemas from the target schemas directory."
+    }),
+    collection: _core.Flags.string({
+        summary: "The object collection key for object schemas."
+    }),
+    "schemas-dir": _flag.dirPath({
+        summary: "The target schemas directory path."
+    })
+});
+_define_property(SchemaPush, "args", {
+    itemType: _core.Args.string({
+        required: false
+    })
+});