@spica/cli 0.18.17 → 0.18.18-pre2

package/index.js

@@ -1,39 +1,3517 @@
+// apps/cli/index.ts
+import caporalCore4 from "@caporal/core";
+
+// apps/cli/src/console.ts
+import { blue, bold, red, yellow } from "colorette";
+import columnify from "columnify";
+import ora from "ora";
+import util from "util";
+function spin(options) {
+  const spinner = ora({ ...options, color: options.color || "yellow" });
+  if (typeof options.op == "function") {
+    options.op = options.op(spinner);
+  }
+  if (options.op instanceof Promise) {
+    spinner.start();
+    return options.op.then(
+      (result) => {
+        spinner.succeed();
+        return result;
+      },
+      (error) => {
+        spinner.fail();
+        if (typeof error == "object" && "message" in error) {
+          console.error(error.message);
+          console.debug(error);
+          process.exit();
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  return spinner.start();
+}
+var Logger = class extends console.Console {
+  error(message, ...optionalParams) {
+    super.error(bold(red(util.format(message, ...optionalParams))));
+  }
+  warn(message, ...optionalParams) {
+    super.warn(bold(yellow(util.format(message, ...optionalParams))));
+  }
+  info(message, ...optionalParams) {
+    super.info(bold(blue(util.format(message, ...optionalParams))));
+  }
+  table(tabularData, columns) {
+    if (!columns) {
+      super.log(columnify(tabularData, { columnSplitter: "       " }));
+    } else {
+      super.log(columnify(tabularData, { columns, columnSplitter: "       " }));
+    }
+  }
+};
+global.console = new Logger(process.stdout, process.stderr);
+
+// apps/cli/src/http.ts
+import axios from "axios";
+
+// apps/cli/src/context.ts
+import fs2 from "fs";
+import os2 from "os";
+import path from "path";
+
+// apps/cli/src/config.ts
+import { cosmiconfig } from "cosmiconfig";
+import fs from "fs";
+import os from "os";
+import _path from "path";
+var config;
+((config2) => {
+  const explorer = cosmiconfig("spica", {
+    searchPlaces: [
+      `.spicarc`,
+      `.spicarc.json`,
+      `.spicarc.yaml`,
+      `.spicarc.yml`,
+      `.spicarc.js`,
+      `.spicarc.cjs`
+    ]
+  });
+  async function has() {
+    const config3 = await get();
+    return !!config3.context;
+  }
+  config2.has = has;
+  async function get() {
+    let searchResult = await explorer.search(process.cwd());
+    if (!searchResult) {
+      searchResult = await explorer.search(os.homedir());
+    }
+    if (!searchResult || !searchResult.config || !searchResult.config.context) {
+      throw new Error(
+        `No context has been selected.
+$\xA0spica context switch <name> to switch context.`
+      );
+    }
+    return searchResult.config;
+  }
+  config2.get = get;
+  async function path9() {
+    let config3 = await explorer.search(process.cwd());
+    if (!config3) {
+      config3 = await explorer.search(os.homedir());
+    }
+    if (config3) {
+      return config3.filepath;
+    }
+    return void 0;
+  }
+  config2.path = path9;
+  async function set(config3) {
+    let configPath = await path9();
+    if (!configPath) {
+      configPath = _path.join(os.homedir(), ".spicarc");
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config3, void 0, 2));
+  }
+  config2.set = set;
+})(config || (config = {}));
+
+// apps/cli/src/context.ts
+var context;
+((context2) => {
+  const ctxPath = path.join(os2.homedir(), ".spicactx");
+  function load() {
+    if (!fs2.existsSync(ctxPath)) {
+      return {};
+    }
+    return JSON.parse(fs2.readFileSync(ctxPath).toString());
+  }
+  function write(ctxs) {
+    fs2.writeFileSync(ctxPath, JSON.stringify(ctxs));
+  }
+  function set(name, data) {
+    const cxts = load();
+    cxts[name] = data;
+    write(cxts);
+  }
+  context2.set = set;
+  function has(name) {
+    const cxts = load();
+    return !!cxts[name];
+  }
+  context2.has = has;
+  function get(name) {
+    const cxts = load();
+    const ctx = cxts[name];
+    if (!ctx) {
+      throw new Error(
+        `Could not find the context ${name}
+$\xA0spica context set --name="${name}" --apikey="<APIKEY_HERE>" to create this context.`
+      );
+    }
+    return ctx;
+  }
+  context2.get = get;
+  async function getCurrent() {
+    const { context: name } = await config.get();
+    return get(name);
+  }
+  context2.getCurrent = getCurrent;
+  function list2() {
+    const cxts = load();
+    return Object.entries(cxts).map(([name, ctx]) => ({ ...ctx, name }));
+  }
+  context2.list = list2;
+  function remove2(name) {
+    const cxts = load();
+    delete cxts[name];
+    write(cxts);
+  }
+  context2.remove = remove2;
+})(context || (context = {}));
+
+// apps/cli/src/http.ts
+var httpService;
+((httpService2) => {
+  function create2({
+    baseUrl,
+    authorization
+  }) {
+    const instance = axios.create({
+      baseURL: baseUrl
+    });
+    instance.interceptors.response.use(
+      (response) => {
+        return response.data;
+      },
+      (error) => {
+        if (!error.response) {
+          return Promise.reject(error);
+        }
+        return Promise.reject(error.response.data || error.response);
+      }
+    );
+    instance.defaults.headers.common["Authorization"] = authorization;
+    return instance;
+  }
+  httpService2.create = create2;
+  async function createFromCurrentCtx() {
+    const ctx = await context.getCurrent();
+    return create2({
+      baseUrl: ctx.url,
+      authorization: ctx.authorization
+    });
+  }
+  httpService2.createFromCurrentCtx = createFromCurrentCtx;
+})(httpService || (httpService = {}));
+
+// apps/cli/src/representative.ts
+import fs3 from "fs";
+import path2 from "path";
+import YAML from "yaml";
+import dotenv from "dotenv";
+var RepresentativeManager = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.serializer = /* @__PURE__ */ new Map();
+    this.parsers = /* @__PURE__ */ new Map();
+    this.serializer.set("json", (val) => JSON.stringify(val));
+    this.parsers.set("json", (val) => JSON.parse(val));
+    this.serializer.set("yaml", (val) => {
+      const document = new YAML.Document();
+      document.contents = val;
+      return document.toString();
+    });
+    this.parsers.set("yaml", (val) => YAML.parse(val));
+    this.serializer.set("js", (val) => val);
+    this.parsers.set("js", (val) => val);
+    this.serializer.set("ts", (val) => val);
+    this.parsers.set("ts", (val) => val);
+    this.serializer.set("env", (content) => {
+      let lines = [];
+      for (const [key, value] of Object.entries(content)) {
+        lines.push(`${key}=${value}`);
+      }
+      return lines.join("\n");
+    });
+    this.parsers.set("env", (content) => {
+      return dotenv.parse(content);
+    });
+  }
+  getModuleDir(module) {
+    return path2.join(this.cwd, module);
+  }
+  serializeContent(content, extension) {
+    const serializer = this.serializer.get(extension);
+    if (!serializer) {
+      throw Error(`Unknown extension type ${extension}`);
+    }
+    return serializer(content);
+  }
+  parseContent(content, extension) {
+    const parser = this.parsers.get(extension);
+    if (!parser) {
+      throw Error(`Unknown extension type ${extension}`);
+    }
+    return parser(content);
+  }
+  write(module, id, fileName, content, extension) {
+    const resourcesDirectory = path2.join(this.cwd, module, id);
+    if (!fs3.existsSync(resourcesDirectory)) {
+      fs3.mkdirSync(resourcesDirectory, { recursive: true });
+    }
+    const fullPath = path2.join(resourcesDirectory, `${fileName}.${extension}`);
+    content = this.serializeContent(content, extension);
+    return fs3.promises.writeFile(fullPath, content);
+  }
+  readResource(module, id, fileNames = []) {
+    const moduleDir = this.getModuleDir(module);
+    const resourcesPath = path2.join(moduleDir, id);
+    const contents = {};
+    if (!fs3.existsSync(resourcesPath)) {
+      return Promise.resolve(contents);
+    }
+    let resources = fs3.readdirSync(resourcesPath);
+    if (fileNames.length) {
+      resources = resources.filter((resource) => fileNames.includes(resource));
+    }
+    const promises = [];
+    for (const resource of resources) {
+      const resourcePath = path2.join(resourcesPath, resource);
+      const promise = fs3.promises.readFile(resourcePath).then((content) => {
+        const extension = resource.split(".").pop();
+        const key = resource.replace(`.${extension}`, "");
+        const value = this.parseContent(content.toString(), extension);
+        contents[key] = value;
+      });
+      promises.push(promise);
+    }
+    return Promise.all(promises).then(() => {
+      return { _id: id, contents };
+    });
+  }
+  read(module, resNameValidator, fileNameFilter = []) {
+    const moduleDir = this.getModuleDir(module);
+    let ids;
+    if (!fs3.existsSync(moduleDir)) {
+      ids = [];
+    } else {
+      ids = fs3.readdirSync(moduleDir);
+    }
+    const promises = [];
+    const results = [];
+    for (const id of ids) {
+      if (!resNameValidator(id)) {
+        continue;
+      }
+      const promise = this.readResource(module, id, fileNameFilter).then((resource) => {
+        if (resource.contents && Object.keys(resource.contents).length) {
+          results.push(resource);
+        }
+      });
+      promises.push(promise);
+    }
+    return Promise.all(promises).then(() => results);
+  }
+  rm(module, id) {
+    let dir = this.cwd;
+    if (module) {
+      dir = path2.join(dir, module);
+    }
+    if (id) {
+      dir = path2.join(dir, id);
+    }
+    return fs3.promises.rm(dir, { recursive: true });
+  }
+};
+
+// apps/cli/src/commands/asset/apply.ts
+import path3 from "path";
+import fs4 from "fs";
+import YAML2 from "yaml";
+async function apply({ options }) {
+  const folderPath = options.path || process.cwd();
+  const filename = path3.join(folderPath, "asset.yaml");
+  const rawDocument = fs4.readFileSync(filename).toString();
+  const assetMeta = YAML2.parseDocument(rawDocument).toJSON();
+  console.log("Found Asset:");
+  console.log(` ${assetMeta.name}`);
+  const repManager = new RepresentativeManager(folderPath);
+  const moduleAndFiles = /* @__PURE__ */ new Map();
+  moduleAndFiles.set("bucket", ["schema.yaml"]);
+  moduleAndFiles.set("function", [
+    "schema.yaml",
+    "package.json",
+    "env.env",
+    "index.ts",
+    "index.js"
+  ]);
+  moduleAndFiles.set("preference", ["schema.yaml"]);
+  moduleAndFiles.set("dashboard", ["schema.yaml"]);
+  moduleAndFiles.set("apikey", ["schema.yaml"]);
+  const resourceNameValidator = (id) => id.match(/^([0-9a-fA-F]{24}$)|identity/);
+  const resources = [];
+  console.log("");
+  console.log("Found Resources:");
+  for (let [_module, fileNames] of moduleAndFiles.entries()) {
+    let resource = await repManager.read(_module, resourceNameValidator, fileNames);
+    console.log(` - ${_module}: ${resource.length}`);
+    resource = resource.map((r) => {
+      r.module = _module;
+      return r;
+    });
+    resources.push(...resource);
+  }
+  if (options.dryRun) return;
+  const body = {
+    ...assetMeta,
+    resources
+  };
+  const client = await httpService.createFromCurrentCtx();
+  await client.post("/asset", body);
+  return console.info(`Asset ${body.name} has been uploaded successfully`);
+}
+function apply_default(program2) {
+  return program2.command("asset apply", "Put objects to the API.").option(
+    "--path <path>",
+    "Path of the folder that container asset.yaml file and resources of it. Current working directory is the default value."
+  ).option("--dry-run", "Shows the changes that will be applied to the target instance.").action(apply);
+}
+
+// apps/cli/src/commands/asset/delete.ts
+import fs5 from "fs";
+import YAML3 from "yaml";
+import path4 from "path";
+async function _delete({ options }) {
+  const type = options.type;
+  const folderPath = options.path || process.cwd();
+  const filename = path4.join(folderPath, "asset.yaml");
+  const rawDocument = fs5.readFileSync(filename).toString();
+  const assetMeta = YAML3.parseDocument(rawDocument).toJSON();
+  const client = await httpService.createFromCurrentCtx();
+  const asset = await client.get("/asset", {
+    params: {
+      name: assetMeta.name
+    }
+  }).then((r) => r[0]);
+  if (!asset) {
+    console.error(`Asset ${assetMeta.name} does not exist`);
+    return;
+  }
+  await client.delete(`/asset/${asset._id}`, { params: { type } });
+  return console.info("Asset ${assetMeta.name} has been deleted successfully");
+}
+function delete_default(program2) {
+  return program2.command("asset delete", "Delete objects of the API.").option(
+    "--path <path>",
+    "Path of the folder that container asset.yaml file and resources of it. Current working directory is the default value."
+  ).option("--type <type>", "Deletion type. Available options are 'soft' and 'hard'", {
+    required: true
+  }).action(_delete);
+}
+
+// apps/cli/src/commands/bucket/orm.ts
+import fs6 from "fs";
+import path5 from "path";
+async function orm({ options }) {
+  const PATH = options.path || "";
+  const DESTINATION = path5.join(PATH, "bucket.ts");
+  const httpClient = await httpService.createFromCurrentCtx();
+  const { url } = await context.getCurrent();
+  await spin({
+    text: "Fetching buckets..",
+    op: async (spinner) => {
+      const buckets = await httpClient.get("/bucket");
+      const languages = await httpClient.get("/preference/bucket").then((r) => Object.keys(r.language.available));
+      spinner.text = "Building interface and method definitions..";
+      const warnings = [];
+      const content = Schema.createFileContent(buckets, languages, url, warnings);
+      spinner.text = "Writing to the destination..";
+      fs6.writeFileSync(DESTINATION, content);
+      spinner.text = `Succesfully completed! File url is ${PATH ? DESTINATION : path5.join(process.cwd(), "bucket.ts")}`;
+      if (warnings.length) {
+        spinner.warn(warnings.join());
+      }
+    }
+  });
+}
+function orm_default(program2) {
+  return program2.command(
+    "bucket orm",
+    "Create object relational mapping applied version of @spica-devkit/bucket"
+  ).option(
+    "--path <path>",
+    "Full URL of the destination folder that the file will be created into. The current directory will be used as default"
+  ).action(orm);
+}
+var Schema;
+((Schema2) => {
+  function createFileContent(buckets, languages, apiurl, warnings) {
+    const languagesDefinition = `${languages.map((i) => `'${i}'`).join("|")}`;
+    let lines = [];
+    lines.push("import * as Bucket from '@spica-devkit/bucket';");
+    lines.push(`
+  /**
+   * Call this method before interacting with buckets.
+   * @param initOptions Initialize options to initialize the '@spica-devkit/bucket'.
+   */
+  export function initialize(
+    ...initOptions: Parameters<typeof Bucket.initialize>
+  ) {
+    initOptions[0].publicUrl = '${apiurl}';
+    Bucket.initialize(...initOptions);
+  }`);
+    lines.push(
+      "\n\ntype Rest<T extends any[]> = ((...p: T) => void) extends ((p1: infer P1, ...rest: infer R) => void) ? R : never;"
+    );
+    lines.push("\ntype getArgs = Rest<Parameters<typeof Bucket.data.get>>;");
+    lines.push("\ntype getAllArgs = Rest<Parameters<typeof Bucket.data.getAll>>;");
+    lines.push("\ntype realtimeGetArgs = Rest<Parameters<typeof Bucket.data.realtime.get>>;");
+    lines.push("\ntype realtimeGetAllArgs = Rest<Parameters<typeof Bucket.data.realtime.getAll>>;");
+    lines.push("\ntype id = { _id: string };");
+    lines.push(`
+
+type Find<Targets extends string[], Search extends string> = {
+  [K in keyof Targets]: Targets[K] extends \`\${Search}.\${infer Rest}\`
+    ? Targets[K]
+    : Targets[K] extends \`\${Search}\`
+    ? Targets[K]
+    : never;
+}[number];
+
+type FindRest<T extends string[], S extends string> = {
+  [K in keyof T]: T[K] extends \`\${S}.\${infer Rest}\`
+    ? Rest
+    : never
+}[number]; 
+
+type ConvertEnumToSelection<T extends string[]> = T extends []
+  ? []
+  : T extends (infer U)[]
+  ? [U, ...U[]]
+  : [];
+
+type Props<T> = {
+  [K in keyof T]: K;
+}[keyof T];
+
+type RemoveProps<TClass, TProps extends keyof TClass> = {
+  [K in keyof TClass as K extends TProps ? never : K]: TClass[K];
+};
+
+type AvailableLanguages = ${languagesDefinition}
+
+`);
+    buckets = makeTitlesUnique(buckets, warnings);
+    for (const bucket of buckets) {
+      buildInterface(bucket, languages, lines);
+    }
+    lines = replaceRelations(buckets, lines);
+    lines = addCrud(lines, buckets, languages);
+    return lines.join("");
+  }
+  Schema2.createFileContent = createFileContent;
+  function addCrud(lines, buckets, languages) {
+    const crud = `
+class CRUD<Scheme,Paginate extends boolean = false> {
+  protected options: {
+    headers: {
+      'accept-language'?: string;
+    };
+    queryParams: {
+      limit?: number;
+      skip?: number;
+      sort?: {
+        [T in keyof Scheme]: -1 | 1;
+      };
+      paginate?: boolean;
+
+      relation?: string[];
+      localize?: boolean;
+      filter?: any;
+    };
+  } = {
+    headers: {},
+    queryParams: {},
+  };
+
+  constructor(
+    protected bucketId: string,
+    protected bdService: typeof Bucket.data,
+    protected relationalFields: string[]
+  ) {}
+
+  private normalizeRelations(document: any) {
+    this.relationalFields.forEach((field) => {
+      if (typeof document[field] == 'object' && document[field] !== null) {
+        document[field] = Array.isArray(document[field])
+          ? document[field].map((v: any) => v._id || v)
+          : document[field]._id;
+      }
+    });
+    return document;
+  }
+
+  private buildOptions(options: any) {
+    options = options ? options : this.options;
+    this.options = {
+      headers: {},
+      queryParams: {},
+    };
+    return options;
+  }
+
+  get(...args: getArgs) {
+    args[1] = this.buildOptions(args[1]);
+    return this.bdService.get<Scheme & id>(this.bucketId, ...args);
+  }
+
+  getAll(
+    ...args: getAllArgs
+  ): Paginate extends true
+    ? Promise<Bucket.IndexResult<Scheme>>
+    : Promise<Scheme[]> {
+    args[0] = this.buildOptions(args[0]);
+    return this.bdService.getAll<Scheme & id>(
+      this.bucketId,
+      ...args
+    ) as Paginate extends true
+      ? Promise<Bucket.IndexResult<Scheme>>
+      : Promise<Scheme[]>;
+  }
+
+  insert(document: Omit<Scheme, '_id'>) {
+    document = this.normalizeRelations(document);
+    return this.bdService.insert(this.bucketId, document);
+  }
+  update(document: Scheme & id) {
+    document = this.normalizeRelations(document);
+    return this.bdService.update(this.bucketId, document._id, document);
+  }
+  patch(document: Partial<Scheme> & id) {
+    document = this.normalizeRelations(document);
+    return this.bdService.patch(this.bucketId, document._id, document);
+  }
+
+  remove(documentId: string) {
+    return this.bdService.remove(this.bucketId, documentId);
+  }
+
+  realtime = {
+    get: (...args: realtimeGetArgs) => {
+      return this.bdService.realtime.get<Scheme & id>(
+        this.bucketId,
+        ...args
+      );
+    },
+    getAll: (...args: realtimeGetAllArgs) => {
+      return this.bdService.realtime.getAll<Scheme & id>(
+        this.bucketId,
+        ...args
+      );
+    },
+  };
+}
+
+class Cursor<Scheme,Paginate extends boolean = false> extends CRUD<Scheme,Paginate>{
+  limit(limit: number): any {
+    this.options.queryParams.limit = limit;
+    return this;
+  }
+
+  skip(skip: number): any {
+    this.options.queryParams.skip = skip;
+    return this;
+  }
+
+  sort(sort: { [T in keyof Scheme]: -1 | 1 }): any {
+    this.options.queryParams.sort = sort;
+    return this;
+  }
+
+  filter(filter: any): any {
+    this.options.queryParams.filter = filter;
+    return this;
+  }
+
+  translate(language: AvailableLanguages): any {
+    this.options.headers['accept-language'] = language;
+    return this;
+  }
+
+  paginate(): any {
+    this.options.queryParams.paginate = true;
+    return this;
+  }
+
+  nonLocalize(): any {
+    this.options.queryParams.localize = false;
+    return this;
+  }  
+
+  resolveRelations(relation:any): any {
+    this.options.queryParams.relation = relation;
+    return this;
+  }
+}
+`;
+    lines.push("\n");
+    lines.push(crud);
+    for (let bucket of buckets) {
+      const property = prepareNamespace(bucket.title);
+      const interfaceName = prepareInterfaceTitle(bucket.title);
+      const bucketId = bucket._id;
+      const bdService = "Bucket.data";
+      const relationalFields = getRelationFields(bucket.properties);
+      const relationalFieldsDefinition = `[${relationalFields.map((i) => `'${i}'`).join(",")}]`;
+      const resolveRelationEnums = getResolveRelationEnums(bucket._id, buckets);
+      const resolveRelationEnumsDefinition = resolveRelationEnums.length ? `(${resolveRelationEnums.map((i) => `'${i}'`).join("|")})[]` : "[]";
+      const crudDefinition = `
+const ${interfaceName}RelationFields: string[] = ${relationalFieldsDefinition}
+type ${interfaceName}RelationEnum = ${resolveRelationEnumsDefinition}
+type ${interfaceName}RelationSelection = ConvertEnumToSelection<${interfaceName}RelationEnum>
+type ${interfaceName}CursorMethods<
+  R extends string[] = [],
+  P extends boolean = false,
+  L extends boolean = true
+> = RemoveProps<
+  ${interfaceName}Cursor<R, P, L>,
+  Exclude<Props<CRUD<${interfaceName}<R, L>, P>>, 'get' | 'getAll'>
+>;
+
+class ${interfaceName}Cursor<R extends string[] = [], P extends boolean = false, L extends boolean = true> extends Cursor<${interfaceName}<R,L>,P>{
+  
+  override resolveRelations<Selecteds extends ${interfaceName}RelationSelection>(
+    relations: Selecteds
+  ): ${interfaceName}CursorMethods<Selecteds, P, L> {
+    return super.resolveRelations(relations);
+  }
+
+  override nonLocalize(): ${interfaceName}CursorMethods<R, P, false> {
+    return super.nonLocalize();
+  }
+
+  override limit(limit: number): ${interfaceName}CursorMethods<R, P, L> {
+    return super.limit(limit);
+  }
+
+  override skip(skip: number): ${interfaceName}CursorMethods<R, P, L> {
+    return super.skip(skip);
+  }
+
+  override sort(sort: {
+    [T in keyof ${interfaceName}]: -1 | 1;
+  }): ${interfaceName}CursorMethods<R, P, L> {
+    return super.sort(sort);
+  }
+
+  override filter(filter: any): ${interfaceName}CursorMethods<R, P, L> {
+    return super.filter(filter);
+  }
+
+  override translate(
+    language: AvailableLanguages
+  ): ${interfaceName}CursorMethods<R, P, L> {
+    return super.translate(language);
+  }
+
+  override paginate(): ${interfaceName}CursorMethods<R, true, L> {
+    return super.paginate();
+  }
+
+}
+        `;
+      lines.push(crudDefinition);
+      const definition = `
+export const ${property} = new ${interfaceName}Cursor('${bucketId}',${bdService},${interfaceName}RelationFields)
+`;
+      lines.push(definition);
+    }
+    return lines;
+  }
+  function buildInterface(schema, languages, lines) {
+    const name = prepareInterfaceTitle(schema.title);
+    lines.push(
+      `
+
+export interface ${name}<Relations extends string[] = [], Localize extends boolean = true>{`
+    );
+    lines.push(`
+  _id?: string;`);
+    buildProperties(schema.properties, languages, schema.required || [], "bucket", lines);
+    lines.push("\n}");
+  }
+  function prepareInterfaceTitle(str) {
+    str = replaceNonWords(str);
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  function replaceRelations(buckets, lines) {
+    for (const bucket of buckets) {
+      const target = `<${bucket._id}>`;
+      lines = lines.map((line) => {
+        if (line.includes(target)) {
+          return line.replace(target, prepareInterfaceTitle(bucket.title));
+        }
+        return line;
+      });
+    }
+    return lines;
+  }
+})(Schema || (Schema = {}));
+function buildProperties(props, languages, reqs, bucketOrObject, lines) {
+  if (bucketOrObject == "object") {
+    lines.push("{");
+  }
+  for (const [key, value] of Object.entries(props)) {
+    const reqFlag = !reqs.includes(key) ? "?" : "";
+    lines.push(`
+  ${key + reqFlag}: `);
+    buildPropDef(key, value, languages, lines);
+    lines.push(";");
+  }
+  if (bucketOrObject == "object") {
+    lines.push("}");
+  }
+}
+function buildArray(key, def, languages, lines) {
+  buildPropDef(key, def, languages, lines);
+  lines.push("[]");
+}
+function buildPropDef(key, prop, languages, lines) {
+  if (prop.enum) {
+    lines.push("(");
+    lines.push(
+      // escape the quote character otherwise it breaks the definition
+      prop.enum.map((v) => prop.type == "string" ? `'${v.replace(/'/g, "\\'")}'` : v).join("|")
+    );
+    lines.push(")");
+    return;
+  }
+  switch (prop.type) {
+    case "string":
+    case "textarea":
+    case "color":
+    case "richtext":
+    case "storage":
+      let def = "string";
+      if (prop.options && prop.options.translate) {
+        let nonLocalizedType = {};
+        languages.forEach((l) => nonLocalizedType[l] = "string");
+        nonLocalizedType = JSON.stringify(nonLocalizedType);
+        def = `Localize extends true ? string : ${nonLocalizedType}`;
+      }
+      lines.push(def);
+      break;
+    case "number":
+      lines.push("number");
+      break;
+    case "date":
+      lines.push("Date | string");
+      break;
+    case "boolean":
+      lines.push("boolean");
+      break;
+    case "object":
+      buildProperties(prop.properties, prop.required || [], languages, "object", lines);
+      break;
+    case "array":
+    case "multiselect":
+      buildArray(key, prop.items, languages, lines);
+      break;
+    case "relation":
+      const suffix = prop.relationType == "onetomany" ? "[]" : "";
+      const definition = `Find<Relations,"${key}">[] extends never[] ? string${suffix} : (<${prop.bucketId}><FindRest<Relations,"${key}">[]>&id)${suffix}`;
+      lines.push(definition);
+      break;
+    case "location":
+      lines.push(`{ type: "Point", coordinates: [number,number]}`);
+      break;
+    default:
+      lines.push("any");
+      break;
+  }
+}
+function prepareNamespace(str) {
+  str = replaceNonWords(str);
+  str = str.toLowerCase();
+  if (str.match(/^[0-9]/)) {
+    str = "_" + str;
+  }
+  return str;
+}
+function replaceNonWords(str) {
+  return str.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function getRelationFields(properties) {
+  const fields = [];
+  for (const [key, value] of Object.entries(properties)) {
+    if (value.type == "relation") {
+      fields.push(key);
+    }
+  }
+  return fields;
+}
+function makeTitlesUnique(buckets, warnings) {
+  const titles = [];
+  for (const bucket of buckets) {
+    const title = bucket.title;
+    const count = titles.filter((t) => t == title).length;
+    if (count >= 1) {
+      warnings.push(`It seems there is more than one bucket that has the title '${bucket.title}'. 
+Number suffix will be added but should use unique titles for the best practice.`);
+      bucket.title += count + 1;
+    }
+    titles.push(title);
+  }
+  return buckets;
+}
+function getResolveRelationEnums(id, buckets) {
+  const enums = [];
+  const maxDepth = 5;
+  const _getResolveRelationEnums = (_bucket, prefix) => {
+    const hasRelation = Object.values(_bucket.properties).some((v) => v.type == "relation");
+    if (!hasRelation) {
+      if (prefix && !enums.includes(prefix)) {
+        enums.push(prefix);
+      }
+      return;
+    }
+    Object.entries(_bucket.properties).forEach(([key, value]) => {
+      if (value.type == "relation") {
+        const paths = prefix ? `${prefix}.${key}` : key;
+        const isMaxLengthExceeded = paths.split(".").length > maxDepth;
+        if (isMaxLengthExceeded) {
+          return;
+        }
+        if (!enums.includes(paths)) {
+          enums.push(paths);
+        }
+        const relatedBuckets = buckets.filter((b) => b._id == value.bucketId);
+        relatedBuckets.forEach((b) => _getResolveRelationEnums(b, paths));
+      }
+    });
+  };
+  const targetBucket = buckets.find((b) => b._id == id);
+  _getResolveRelationEnums(targetBucket);
+  return enums;
+}
+
+// apps/cli/src/commands/context/ls.ts
+async function listContexts() {
+  const currentContext = await config.get().catch((e) => {
+    console.warn(e.message);
+    return { context: void 0 };
+  });
+  const contexts = context.list().map((ctx) => {
+    let authorization = new Array(ctx.authorization.length).fill("*").slice(0, 10).join(" ");
+    if (ctx.name == currentContext.context) {
+      authorization = authorization + "   (selected)";
+    }
+    return {
+      ...ctx,
+      authorization
+    };
+  });
+  console.table(contexts, ["name", "url", "authorization"]);
+}
+function ls_default(program2) {
+  return program2.command("context ls", "List contexts").action(listContexts);
+}
+
+// apps/cli/src/commands/context/remove.ts
+async function removeContext({ args }) {
+  const name = args.name;
+  if (!context.has(name)) {
+    return console.error(`Context "${name}" does not exist.`);
+  }
+  context.remove(name);
+  console.info(`Context "${name}" has been deleted.`);
+}
+function remove_default(program2) {
+  return program2.command("context remove", "Remove context").argument("<name>", "Name of the context.").action(removeContext);
+}
+
+// apps/cli/src/commands/context/set.ts
+import axios2 from "axios";
+async function addContext({ options }) {
+  const name = options.name;
+  const apikey = options.apikey;
+  const url = options.url;
+  const rest = axios2.create({
+    baseURL: url,
+    headers: {
+      Authorization: `APIKEY ${apikey}`
+    }
+  });
+  try {
+    await rest.get("/passport/identity/statements");
+    const exists = context.has(name);
+    context.set(name, { url, authorization: `APIKEY ${apikey}` });
+    console.info(`Context "${name}" is successfully ${exists ? "set" : "added"}.`);
+  } catch (error) {
+    if (error.response) {
+      console.error(
+        `Error from server (${error.response.statusText}): ${error.response.data.message}`
+      );
+    } else if (error.request) {
+      console.error(
+        `Error (${error.code}): Something has happened while connecting, ${error.message}`
+      );
+    } else {
+      console.error(`Error: ${error.message}`);
+    }
+  }
+}
+function set_default(program2) {
+  return program2.command("context set", "Set context").option("--name <name>", "Name of the context.").option("--url <url>", "Url of the API.", { required: true }).option("-a <apikey>, --apikey <apikey>", "Authorize via an API Key.", { required: true }).action(addContext);
+}
+
+// apps/cli/src/commands/context/switch.ts
+async function switchContext({ args }) {
+  const name = args.name;
+  if (!context.has(name)) {
+    console.error(`Could not found the context "${name}". You can add it by running; `);
+    console.log("");
+    console.log(`$ spica context add --name=${name} --url=URL_HERE --apikey=APIKEY_HERE`);
+    return;
+  }
+  await config.set({
+    context: name
+  });
+  console.info(`Context has been changed to "${name}".`);
+}
+function switch_default(program2) {
+  return program2.command("context switch", "Switch context").argument("<name>", "Name of the context.").action(switchContext);
+}
+
+// apps/cli/src/commands/function/orm.ts
+import path7 from "path";
+import fs7 from "fs";
+
+// apps/cli/src/compile.ts
+import ts5 from "typescript";
+
+// apps/cli/src/function/helpers.ts
+import ts from "typescript";
+function getFunctionName(node) {
+  if (node.name) {
+    return node.name.escapedText;
+  }
+  const isDefault = node.modifiers?.findIndex((m) => m.kind == ts.SyntaxKind.DefaultKeyword) != -1;
+  if (isDefault) {
+    return "default";
+  }
+  return void 0;
+}
+
+// apps/cli/src/function/triggers/http/services/axios.ts
+import ts3 from "typescript";
+
+// apps/cli/src/function/modifier.ts
+import ts2 from "typescript";
+var FunctionDeclarationModifier = class {
+  constructor(node) {
+    this.node = node;
+  }
+  setAllDeclarationDependencies() {
+    this.modifiers = this.setModifiers();
+    this.name = this.setName();
+    this.body = this.setBody();
+    this.parameters = this.setParameters();
+    this.decorators = this.setDecorators();
+    this.asteriksToken = this.setAsteriksToken();
+    this.typeParameters = this.setTypeParameters();
+    this.type = this.setType();
+  }
+  modify() {
+    this.setAllDeclarationDependencies();
+    return ts2.factory.updateFunctionDeclaration(
+      this.node,
+      this.modifiers,
+      this.asteriksToken,
+      this.name,
+      this.typeParameters,
+      this.parameters,
+      this.type,
+      this.body
+    );
+  }
+};
+var SpicaFunctionModifier = class extends FunctionDeclarationModifier {
+  setBody() {
+    return void 0;
+  }
+  setParameters() {
+    return [];
+  }
+  setDecorators() {
+    return void 0;
+  }
+  setAsteriksToken() {
+    return void 0;
+  }
+  setTypeParameters() {
+    return void 0;
+  }
+  setType() {
+    return void 0;
+  }
+  constructor(node, handler) {
+    super(node);
+    this.handler = handler;
+  }
+  get isHandlerDefault() {
+    return this.handler == "default";
+  }
+  setModifiers() {
+    const modifiers = [ts2.factory.createModifier(ts2.SyntaxKind.ExportKeyword)];
+    if (this.isHandlerDefault) {
+      modifiers.push(ts2.factory.createModifier(ts2.SyntaxKind.DefaultKeyword));
+    }
+    return modifiers;
+  }
+  setName() {
+    return !this.isHandlerDefault ? ts2.factory.createIdentifier(this.handler) : void 0;
+  }
+  getImports() {
+    return [];
+  }
+  getExtraFunctionDeclarations() {
+    return [];
+  }
+};
+
+// apps/cli/src/function/triggers/http/services/axios.ts
+var Axios = class extends SpicaFunctionModifier {
+  constructor(node, handler, baseUrl, trigger, validators = axiosValidators) {
+    super(node, handler);
+    this.validators = validators;
+    this.extraFunctionDeclarations = [];
+    this.registeredValidators = [];
+    this.url = `${baseUrl}/fn-execute${trigger.options.path}`;
+    this.method = trigger.options.method;
+    for (const factory of this.validators) {
+      const emptyFn = ts3.factory.createFunctionDeclaration(
+        [],
+        void 0,
+        void 0,
+        [],
+        [],
+        void 0,
+        void 0
+      );
+      const validator = factory(emptyFn);
+      this.registeredValidators.push(validator);
+      this.extraFunctionDeclarations.push(validator.modify());
+    }
+  }
+  static {
+    this.modifierName = "axios";
+  }
+  getExtraFunctionDeclarations() {
+    return this.extraFunctionDeclarations;
+  }
+  getImports() {
+    const importClause = ts3.factory.createImportClause(
+      false,
+      ts3.factory.createIdentifier("axios"),
+      void 0
+    );
+    const importDeclaration = ts3.factory.createImportDeclaration(
+      void 0,
+      importClause,
+      ts3.factory.createStringLiteral("axios")
+    );
+    return [importDeclaration];
+  }
+  setParameters() {
+    return [
+      ts3.factory.createParameterDeclaration(
+        void 0,
+        void 0,
+        ts3.factory.createIdentifier("config"),
+        void 0,
+        void 0,
+        void 0
+      )
+    ];
+  }
+  setBody() {
+    const configValue = ts3.factory.createObjectLiteralExpression([
+      ts3.factory.createSpreadAssignment(ts3.factory.createIdentifier("config")),
+      ts3.factory.createPropertyAssignment(
+        ts3.factory.createIdentifier("method"),
+        ts3.factory.createStringLiteral(this.method.toLowerCase())
+      ),
+      ts3.factory.createPropertyAssignment(
+        ts3.factory.createIdentifier("url"),
+        ts3.factory.createStringLiteral(this.url)
+      )
+    ]);
+    const configAssigment = ts3.factory.createBinaryExpression(
+      ts3.factory.createIdentifier("config"),
+      ts3.SyntaxKind.FirstAssignment,
+      configValue
+    );
+    const configStatement = ts3.factory.createExpressionStatement(configAssigment);
+    const validatorCalls = [];
+    for (const validator of this.registeredValidators) {
+      const call = ts3.factory.createCallExpression(validator.name, void 0, [
+        ts3.factory.createIdentifier("config")
+      ]);
+      validatorCalls.push(ts3.factory.createExpressionStatement(call));
+    }
+    const requestAccess = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("axios"),
+      ts3.factory.createIdentifier("request")
+    );
+    const requestArgs = [ts3.factory.createIdentifier("config")];
+    const requestCall = ts3.factory.createCallExpression(requestAccess, void 0, requestArgs);
+    const thenParams = [
+      ts3.factory.createParameterDeclaration(
+        void 0,
+        void 0,
+        ts3.factory.createIdentifier("r"),
+        void 0,
+        void 0,
+        void 0
+      )
+    ];
+    const thenBody = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("r"),
+      ts3.factory.createIdentifier("data")
+    );
+    const thenArgs = ts3.factory.createArrowFunction(
+      void 0,
+      void 0,
+      thenParams,
+      void 0,
+      ts3.factory.createToken(ts3.SyntaxKind.EqualsGreaterThanToken),
+      thenBody
+    );
+    const thenAccess = ts3.factory.createPropertyAccessExpression(
+      requestCall,
+      ts3.factory.createIdentifier("then")
+    );
+    const thenCall = ts3.factory.createCallExpression(thenAccess, void 0, [thenArgs]);
+    const returnStatement = ts3.factory.createReturnStatement(thenCall);
+    return ts3.factory.createBlock([configStatement, ...validatorCalls, returnStatement], true);
+  }
+};
+var AxiosWriteValidator = class _AxiosWriteValidator extends FunctionDeclarationModifier {
+  static {
+    this.modifierName = "axiosWriteValidator";
+  }
+  setAsteriksToken() {
+    return void 0;
+  }
+  setTypeParameters() {
+    return [];
+  }
+  setModifiers() {
+    return [];
+  }
+  setType() {
+    return void 0;
+  }
+  setDecorators() {
+    return [];
+  }
+  getImports() {
+    return [];
+  }
+  getExtraFunctionDeclarations() {
+    return [];
+  }
+  setName() {
+    return ts3.factory.createIdentifier(_AxiosWriteValidator.modifierName);
+  }
+  setParameters() {
+    return [
+      ts3.factory.createParameterDeclaration(
+        void 0,
+        void 0,
+        ts3.factory.createIdentifier("config")
+      )
+    ];
+  }
+  setBody() {
+    const writeMethods = ["post", "put", "patch"];
+    const writeMethodsArray = ts3.factory.createArrayLiteralExpression(
+      writeMethods.map((m) => ts3.factory.createStringLiteral(m)),
+      false
+    );
+    const includes = ts3.factory.createPropertyAccessExpression(
+      writeMethodsArray,
+      ts3.factory.createIdentifier("includes")
+    );
+    const configMethodAccess = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("config"),
+      ts3.factory.createIdentifier("method")
+    );
+    const includesCall = ts3.factory.createCallExpression(includes, void 0, [configMethodAccess]);
+    const configData = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("config"),
+      ts3.factory.createIdentifier("data")
+    );
+    const binaryExpression = ts3.factory.createLogicalAnd(
+      includesCall,
+      ts3.factory.createPrefixUnaryExpression(ts3.SyntaxKind.ExclamationToken, configData)
+    );
+    const warningMessage = `Sending empty request body for ${writeMethods.join(
+      ", "
+    )} requests is unusual. If it's not intented, please use config.data or update your spica function.`;
+    const consoleWarnAccess = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("console"),
+      ts3.factory.createIdentifier("warn")
+    );
+    const consoleWarnCall = ts3.factory.createCallExpression(
+      consoleWarnAccess,
+      [],
+      [ts3.factory.createStringLiteral(warningMessage)]
+    );
+    const ifStatementBody = ts3.factory.createBlock(
+      [ts3.factory.createExpressionStatement(consoleWarnCall)],
+      true
+    );
+    const IfStatement = ts3.factory.createIfStatement(binaryExpression, ifStatementBody);
+    return ts3.factory.createBlock([IfStatement], true);
+  }
+};
+var AxiosReadValidator = class _AxiosReadValidator extends FunctionDeclarationModifier {
+  static {
+    this.modifierName = "axiosReadValidator";
+  }
+  setAsteriksToken() {
+    return void 0;
+  }
+  setTypeParameters() {
+    return [];
+  }
+  setModifiers() {
+    return [];
+  }
+  setType() {
+    return void 0;
+  }
+  setDecorators() {
+    return [];
+  }
+  getImports() {
+    return [];
+  }
+  getExtraFunctionDeclarations() {
+    return [];
+  }
+  setName() {
+    return ts3.factory.createIdentifier(_AxiosReadValidator.modifierName);
+  }
+  setParameters() {
+    return [
+      ts3.factory.createParameterDeclaration(
+        void 0,
+        void 0,
+        ts3.factory.createIdentifier("config")
+      )
+    ];
+  }
+  setBody() {
+    const readMethods = ["get", "delete", "trace", "options", "head"];
+    const readMethodsArray = ts3.factory.createArrayLiteralExpression(
+      readMethods.map((m) => ts3.factory.createStringLiteral(m)),
+      false
+    );
+    const includes = ts3.factory.createPropertyAccessExpression(
+      readMethodsArray,
+      ts3.factory.createIdentifier("includes")
+    );
+    const configMethodAccess = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("config"),
+      ts3.factory.createIdentifier("method")
+    );
+    const includesCall = ts3.factory.createCallExpression(includes, void 0, [configMethodAccess]);
+    const configData = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("config"),
+      ts3.factory.createIdentifier("data")
+    );
+    const binaryExpression = ts3.factory.createLogicalAnd(includesCall, configData);
+    const warningMessage = `Sending request body for ${readMethods.join(
+      ", "
+    )} requests is unusual. If it's not intented, please remove config.data or update your spica function.`;
+    const consoleWarnAccess = ts3.factory.createPropertyAccessExpression(
+      ts3.factory.createIdentifier("console"),
+      ts3.factory.createIdentifier("warn")
+    );
+    const consoleWarnCall = ts3.factory.createCallExpression(
+      consoleWarnAccess,
+      [],
+      [ts3.factory.createStringLiteral(warningMessage)]
+    );
+    const ifStatementBody = ts3.factory.createBlock(
+      [ts3.factory.createExpressionStatement(consoleWarnCall)],
+      true
+    );
+    const IfStatement = ts3.factory.createIfStatement(binaryExpression, ifStatementBody);
+    return ts3.factory.createBlock([IfStatement], true);
+  }
+};
+var axiosValidators = [
+  (node) => new AxiosWriteValidator(node),
+  (node) => new AxiosReadValidator(node)
+];
+var axios3 = {
+  name: Axios.modifierName,
+  factory: (node, handler, baseUrl, trigger) => new Axios(node, handler, baseUrl, trigger)
+};
+
+// apps/cli/src/function/triggers/http/services/index.ts
+var httpServiceModifiers = /* @__PURE__ */ new Map([[axios3.name, axios3.factory]]);
+
+// apps/cli/src/function/triggers/http/transformer.ts
+import ts4 from "typescript";
+var HttpTransformer = class {
+  constructor(triggers, baseUrl, options, modifiers = httpServiceModifiers) {
+    this.triggers = triggers;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    this.modifiers = modifiers;
+    this.importsAdded = false;
+    this.extraFnsAdded = false;
+    const factory = this.modifiers.get(options.selectedService);
+    if (!factory) {
+      throw new Error(`Http service named ${options.selectedService} is not implemented yet`);
+    }
+    this.modifier = factory;
+  }
+  static {
+    this._name = "http";
+  }
+  getTransformer() {
+    const transformer = (context2) => (rootNode) => {
+      const visitor = this.getVisitor(this.triggers, context2);
+      return ts4.visitNode(rootNode, visitor);
+    };
+    return transformer;
+  }
+  getVisitor(triggers, context2) {
+    const visitor = (node) => {
+      if (ts4.isSourceFile(node)) {
+        return ts4.visitEachChild(node, visitor, context2);
+      }
+      const handler = ts4.isFunctionDeclaration(node) ? getFunctionName(node) : void 0;
+      if (!handler || !triggers[handler]) {
+        return node;
+      }
+      const modifier = this.modifier(
+        node,
+        handler,
+        this.baseUrl,
+        triggers[handler]
+      );
+      if (!this.importsAdded) {
+        this.options.addImports(modifier.getImports());
+        this.importsAdded = true;
+      }
+      if (!this.extraFnsAdded) {
+        this.options.addExtraFunctions(modifier.getExtraFunctionDeclarations());
+        this.extraFnsAdded = true;
+      }
+      return modifier.modify();
+    };
+    return visitor;
+  }
+};
+
+// apps/cli/src/function/triggers/http/index.ts
+var http = {
+  name: HttpTransformer._name,
+  factory: (triggers, baseUrl, options) => new HttpTransformer(triggers, baseUrl, options, httpServiceModifiers)
+};
+
+// apps/cli/src/function/triggers/index.ts
+var triggerTransformers = /* @__PURE__ */ new Map([
+  [http.name, http.factory]
+]);
+
+// apps/cli/src/compile.ts
+var FunctionCompiler = class {
+  constructor(fn, triggerTypes, baseUrl, triggerOptions, transformers = triggerTransformers) {
+    this.fn = fn;
+    this.triggerTypes = triggerTypes;
+    this.baseUrl = baseUrl;
+    this.triggerOptions = triggerOptions;
+    this.transformers = transformers;
+    this.fn.triggers = this.filterTriggers(
+      this.fn.triggers,
+      ([_, trigger]) => this.triggerTypes.includes(trigger.type)
+    );
+    this.sourceFile = ts5.createSourceFile(fn.name, fn.index, ts5.ScriptTarget.Latest);
+  }
+  compile() {
+    const transformers = [];
+    const imports = [];
+    const extraFunctions = [];
+    const addImports = (_imports) => imports.push(..._imports);
+    const addExtraFunctions = (fns) => extraFunctions.push(...fns);
+    const handlerNames = this.getHandlerNames();
+    const handlerFilterer = this.getHandlerFiltererTransformer(handlerNames);
+    transformers.push(handlerFilterer);
+    for (const triggerType of this.triggerTypes) {
+      const factory = this.transformers.get(triggerType);
+      if (!factory) {
+        throw Error(`Trigger type ${triggerType} does not have any transformer.`);
+      }
+      const relevantTriggers = this.filterTriggers(
+        this.fn.triggers,
+        ([_, trigger]) => trigger.type == triggerType
+      );
+      if (!Object.keys(relevantTriggers).length) {
+        continue;
+      }
+      const transformerOptions = {
+        ...this.triggerOptions[triggerType],
+        addImports,
+        addExtraFunctions
+      };
+      const transformer = factory(relevantTriggers, this.baseUrl, transformerOptions);
+      transformers.push(transformer.getTransformer());
+    }
+    this.sourceFile = ts5.transform(this.sourceFile, transformers).transformed[0];
+    this.sourceFile = ts5.factory.updateSourceFile(this.sourceFile, [
+      ...imports,
+      ...this.sourceFile.statements,
+      ...extraFunctions
+    ]);
+    const code = ts5.createPrinter().printFile(this.sourceFile);
+    switch (this.fn.language) {
+      case "typescript":
+        return [{ extension: "ts", content: code }];
+      case "javascript":
+        const types = this.generateTypesOfCode(code);
+        return [
+          { extension: "js", content: code },
+          { extension: "d.ts", content: types }
+        ];
+      default:
+        throw Error(`Language named ${this.fn.language} has no compiler yet.`);
+    }
+  }
+  getHandlerNames() {
+    return Object.keys(this.fn.triggers);
+  }
+  filterTriggers(triggers, filter) {
+    return Object.entries(triggers).filter(filter).reduce((acc, [handler, trigger]) => {
+      acc[handler] = trigger;
+      return acc;
+    }, {});
+  }
+  getHandlerFiltererTransformer(handlerNames) {
+    const transformer = (context2) => (rootNode) => {
+      const visitor = (node) => {
+        const isRootNode = node.kind == ts5.SyntaxKind.SourceFile;
+        if (isRootNode) {
+          return ts5.visitEachChild(node, visitor, context2);
+        }
+        const isNecessaryStatement = ts5.isFunctionDeclaration(node) ? handlerNames.includes(getFunctionName(node)) : false;
+        if (!isNecessaryStatement) {
+          return this.disableStatement(node);
+        }
+        return node;
+      };
+      return ts5.visitNode(rootNode, visitor);
+    };
+    return transformer;
+  }
+  codeToAst(code) {
+    return ts5.createSourceFile("name.ts", code, ts5.ScriptTarget.Latest);
+  }
+  // export function clearEmptyStatementTraces(code: string) {
+  //   return code.replace(/^;[\n|;]*$\n/gm, "");
+  // }
+  disableStatement(node) {
+    node = ts5.factory.createEmptyStatement();
+    node = ts5.addSyntheticLeadingComment(
+      node,
+      ts5.SyntaxKind.SingleLineCommentTrivia,
+      " This statement has been deleted."
+    );
+    return node;
+  }
+  generateTypesOfCode(code) {
+    let types;
+    const options = {
+      allowJs: true,
+      declaration: true,
+      emitDeclarationOnly: true
+    };
+    const host = ts5.createCompilerHost(options);
+    host.writeFile = (_, data) => {
+      types = data;
+    };
+    host.readFile = () => code;
+    const program2 = ts5.createProgram(["dummy.js"], options, host);
+    program2.emit();
+    return types;
+  }
+};
+
+// apps/cli/src/validator.ts
+import { bold as bold2, green, red as red2 } from "colorette";
+import * as path6 from "path";
+function projectName(input) {
+  if (input && !input.match(/^[a-z][a-z0-9]+(?:-[a-z0-9]+)*$/)) {
+    throw new Error(
+      `${red2(input)} is an invalid project name.
+It should be in format like ${bold2("infra1")}, ${bold2("infra-1")} or ${bold2("project-1")}`
+    );
+  }
+  return input;
+}
+function projectLocalResourceFolder(input) {
+  if (!path6.isAbsolute(input)) {
+    throw new Error(
+      `${red2(input)} is not an absolute path.
+Please provide a full path starting with ${bold2("/")}, like ${bold2("/home/user/project")}`
+    );
+  }
+  return input;
+}
+var availableSyncModules = [
+  "bucket",
+  "function",
+  "bucket-data",
+  "apikey",
+  "policy",
+  "env-var"
+];
+function validateSyncModules(input) {
+  const moduleNames = input.split(",").map((m) => m.trim());
+  if (!moduleNames.length) {
+    throw new Error(`You should select one or more of these modules:
+${availableSyncModules.map((m) => `- ${green(m)}`).join("\n")}`);
+  }
+  const nonMigratables = moduleNames.filter((module) => availableSyncModules.indexOf(module) == -1);
+  if (nonMigratables.length) {
+    throw new Error(`Some of selected modules are not valid:
+${nonMigratables.map((m) => `- ${red2(m)}`).join("\n")}
+
+Synchronizable modules are:
+${availableSyncModules.map((m) => `- ${green(m)}`).join("\n")}
+    `);
+  }
+  return input;
+}
+function validateSyncIds(input) {
+  if (typeof input !== "string") {
+    throw new Error("You should provide a comma separated string");
+  }
+  return input;
+}
+var availableHttpServices = ["axios"];
+function separateToNewLines(iterable, colorCtor) {
+  return iterable.map((i) => `- ${colorCtor ? colorCtor(i) : i}`).join("\n");
+}
+
+// apps/cli/src/commands/function/orm.ts
+import { green as green2 } from "colorette";
+async function orm2({ options }) {
+  const PATH = options.path || path7.join(process.cwd(), "functions");
+  const TRIGGER_TYPES = options.triggerTypes;
+  const HTTP_SERVICE = options.httpService;
+  const httpClient = await httpService.createFromCurrentCtx();
+  const { url } = await context.getCurrent();
+  await spin({
+    text: "Fetching functions..",
+    op: async (spinner) => {
+      const functions = await httpClient.get("/function").then((r) => {
+        const fns = r;
+        const promises = fns.map(
+          (fn) => httpClient.get(`/function/${fn._id}/index`).then((r2) => {
+            fn.index = r2.index;
+          })
+        );
+        return Promise.all(promises).then(() => fns);
+      });
+      spinner.text = "Building interface and method definitions..";
+      if (!fs7.existsSync(PATH)) {
+        fs7.mkdirSync(PATH);
+      }
+      const writeFilePromises = [];
+      for (const fn of functions) {
+        const options2 = {
+          http: { selectedService: HTTP_SERVICE }
+        };
+        const sources = new FunctionCompiler(fn, TRIGGER_TYPES, url, options2).compile();
+        const replacedName = fn.name.replace(/ /gm, "_").replace(/\//g, "__");
+        const folderPath = path7.join(PATH, replacedName);
+        if (!fs7.existsSync(folderPath)) {
+          fs7.mkdirSync(folderPath);
+        }
+        for (const source of sources) {
+          const _path2 = path7.join(folderPath, `index.${source.extension}`);
+          writeFilePromises.push(fs7.promises.writeFile(_path2, source.content, {}));
+        }
+      }
+      spinner.text = "Writing to the destination..";
+      await Promise.all(writeFilePromises);
+      spinner.text = `Succesfully completed! Folder url is ${PATH}`;
+    }
+  });
+}
+function orm_default2(program2) {
+  return program2.command(
+    "function orm",
+    "Create object relational mapping applied files to interact with Spica Cloud Functions"
+  ).option(
+    "--path <path>",
+    "Full URL of the destination folder that the files will be created into. The current directory will be used as default"
+  ).option(
+    "--trigger-types <trigger-types>",
+    "Trigger types that will be filtered. Default value is http.",
+    {
+      default: ["http"]
+    }
+  ).option(
+    "--http-service <http-service>",
+    `Third party library that is responsible for sending http requests. Available services are: ${separateToNewLines(
+      availableHttpServices,
+      green2
+    )}}.`,
+    {
+      default: "axios"
+    }
+  ).action(orm2);
+}
+
+// apps/cli/src/commands/project/ls.ts
+import docker from "dockerode";
+import duration from "pretty-ms";
+async function list() {
+  const machine2 = new docker();
+  const foundNetworks = await machine2.listNetworks({
+    filters: JSON.stringify({ label: { namespace: true } })
+  });
+  const instances = [];
+  for (const network of foundNetworks) {
+    const containers = await machine2.listContainers({
+      all: true,
+      filters: JSON.stringify({ label: [`namespace=${network["Labels"].namespace}`] })
+    });
+    const namespace = network["Labels"].namespace;
+    const instance = {
+      NAMESPACE: namespace,
+      DESCRIPTION: [],
+      PORT: "-",
+      AGE: "-",
+      VERSION: "-",
+      STATUS: "-"
+    };
+    instances.push(instance);
+    const api = containers.find(
+      (container) => container.Names.some((name) => name.indexOf(`${namespace}-api`) != -1)
+    );
+    const spica = containers.find(
+      (container) => container.Names.some((name) => name.indexOf(`${namespace}-spica`) != -1)
+    );
+    const ingress = containers.find(
+      (container) => container.Names.some((name) => name.indexOf(`${namespace}-ingress`) != -1)
+    );
+    if (api && spica && ingress) {
+      instance.VERSION = api.Image.split(":")[1];
+      instance.AGE = duration(new Date(api.Created * 1e3).getTime());
+      if (ingress.State == "running" && ingress.Ports.length) {
+        const [port] = ingress.Ports;
+        instance.PORT = `${port.IP}:${port.PublicPort}`;
+      }
+      if (api.State == "running" && spica.State == "running" && ingress.State == "running") {
+        instance.STATE = ingress.State;
+        instance.STATUS = ingress.Status;
+      } else {
+        const downContainer = ingress.State != "running" ? ingress : api.State != "running" ? api : spica;
+        instance.STATUS = downContainer.Status;
+        instance.DESCRIPTION.push(
+          `The container ${downContainer.Image.startsWith("nginx") ? "Ingress" : downContainer.Names[0].slice(1)} is down.`
+        );
+      }
+    }
+    const databaseContainers = containers.filter((container) => container.Image.startsWith("mongo"));
+    const runningDatabaseContainers = containers.filter(
+      (container) => container.Image.startsWith("mongo") && container.State == "running"
+    );
+    if (runningDatabaseContainers.length != databaseContainers.length) {
+      instance.DESCRIPTION.push(`Some database containers are down.`);
+    }
+  }
+  console.table(instances, ["NAMESPACE", "AGE", "STATUS", "VERSION", "PORT", "DESCRIPTION"]);
+}
+function ls_default2(program2) {
+  return program2.command("project ls", "List local projects.").action(list);
+}
+
+// apps/cli/src/commands/project/remove.ts
+import docker2 from "dockerode";
+async function remove({ args, options }) {
+  const { name } = args;
+  const machine2 = new docker2();
+  const foundNetworks = await machine2.listNetworks({
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  });
+  const foundContainers = await machine2.listContainers({
+    all: true,
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  });
+  if (!foundNetworks.length && !foundContainers.length) {
+    return console.warn(`There is no instance with name ${name}.`);
+  }
+  if (foundContainers.length) {
+    await spin({
+      text: `Removing containers (0/${foundContainers.length}).`,
+      op: (spinner) => {
+        let deleted = 0;
+        function increaseDeletedCount() {
+          deleted++;
+          spinner.text = `Removing containers (${deleted}/${foundContainers.length}).`;
+        }
+        return Promise.all(
+          foundContainers.map(
+            async (containerInfo) => machine2.getContainer(containerInfo.Id).remove({
+              v: true,
+              // Remove volumes attached to the container
+              force: true
+              // Stop if the container running
+            }).then(() => increaseDeletedCount())
+          )
+        );
+      }
+    });
+  }
+  if (foundNetworks.length) {
+    await spin({
+      text: `Removing networks (0/${foundNetworks.length}).`,
+      op: (spinner) => {
+        let deleted = 0;
+        function increaseDeletedCount() {
+          deleted++;
+          spinner.text = `Removing networks (${deleted}/${foundNetworks.length}).`;
+        }
+        return Promise.all(
+          foundNetworks.map(
+            (network) => machine2.getNetwork(network.Id).remove().then(() => increaseDeletedCount())
+          )
+        );
+      }
+    });
+  }
+  if (!options.retainVolumes) {
+    const foundVolumes = (await machine2.listVolumes({
+      filters: JSON.stringify({ label: [`namespace=${name}`] })
+    })).Volumes;
+    await spin({
+      text: `Removing volumes (0/${foundVolumes.length}).`,
+      op: (spinner) => {
+        let deleted = 0;
+        function increaseDeletedCount() {
+          deleted++;
+          spinner.text = `Removing volumes (${deleted}/${foundVolumes.length}).`;
+        }
+        return Promise.all(
+          foundVolumes.map(
+            (volume) => machine2.getVolume(volume.Name).remove().then(() => increaseDeletedCount())
+          )
+        );
+      }
+    });
+  }
+  console.info(`Spica ${name} was successfully deleted.`);
+}
+function remove_default2(program2) {
+  return program2.command("project remove", "Stop and remove a local project.").argument("<name>", "Name of the project to remove.", { validator: projectName }).option("--retain-volumes", "When false, the data will be removed along with the containers.", {
+    default: true
+  }).action(remove);
+}
+
+// apps/cli/src/commands/project/start.ts
 import caporalCore from "@caporal/core";
-const { program } = caporalCore;
-import "./src/console.js";
-import assetApply from "./src/commands/asset/apply.js";
-import assetDelete from "./src/commands/asset/delete.js";
-import bucketOrm from "./src/commands/bucket/orm.js";
-import contextLs from "./src/commands/context/ls.js";
-import contextRemove from "./src/commands/context/remove.js";
-import contextSet from "./src/commands/context/set.js";
-import contextSwitch from "./src/commands/context/switch.js";
-import functionOrm from "./src/commands/function/orm.js";
-import projectLs from "./src/commands/project/ls.js";
-import projectRemove from "./src/commands/project/remove.js";
-import projectStart from "./src/commands/project/start.js";
-import projectSync from "./src/commands/project/sync.js";
-import projectUpgrade from "./src/commands/project/upgrade.js";
-import pkg from "./package.json" with { type: "json" };
-export function run(argv) {
-    program
-        .version(pkg.version)
-        .name("spica")
-        .bin("spica")
-        .description("Command line interface for spica.");
-    assetApply(program);
-    assetDelete(program);
-    bucketOrm(program);
-    contextLs(program);
-    contextRemove(program);
-    contextSet(program);
-    contextSwitch(program);
-    functionOrm(program);
-    projectLs(program);
-    projectRemove(program);
-    projectStart(program);
-    projectSync(program);
-    projectUpgrade(program);
-    return program.run(argv);
-}
-//# sourceMappingURL=index.js.map
+import getport from "get-port";
+import open from "open";
+import path8 from "path";
+import fs8 from "fs";
+
+// apps/cli/src/project.ts
+import docker3 from "dockerode";
+import semver from "semver";
+var machine;
+var DockerMachine = class extends docker3 {
+  constructor() {
+    if (!machine) {
+      super();
+      machine = this;
+    }
+    return machine;
+  }
+  doesImageExist(image, tag) {
+    return machine.listImages({
+      filters: JSON.stringify({ reference: [`${image}:${tag}`] })
+    }).then((images) => images.length > 0);
+  }
+  pullImage(image, tag) {
+    return new Promise(
+      (resolve, reject) => machine.pull(`${image}:${tag}`, {}, function(err, stream) {
+        if (err) {
+          if (err.message && err.message.indexOf(`manifest for ${image}`)) {
+            reject(new ImageNotFoundError(image, tag));
+          } else {
+            reject(err);
+          }
+        } else {
+          machine.modem.followProgress(stream, resolve);
+        }
+      })
+    );
+  }
+};
+var ImageNotFoundError = class extends Error {
+  constructor(image, tag) {
+    super(`Could not find the image ${image}:${tag}.`);
+  }
+};
+var version = (image) => {
+  const vers = /^spicaengine\/(spica|api):(.*)/g.exec(image)[2];
+  if (nonActualVersions.includes(vers)) {
+    return machine.getImage(image).inspect().then((info) => {
+      const actualVersion = info.RepoTags.map((tag) => tag.slice(tag.indexOf(":") + 1)).find(
+        (tag) => semver.valid(tag)
+      );
+      if (!actualVersion) {
+        throw Error(`Could not find the actual version of image '${image}'`);
+      }
+      return actualVersion;
+    });
+  }
+  return Promise.resolve(vers);
+};
+var nonActualVersions = ["latest"];
+function isVersionUpgrade(desiredVersion, oldVersion) {
+  if (desiredVersion == "latest") {
+    return true;
+  }
+  return semver.gt(desiredVersion, oldVersion);
+}
+
+// apps/cli/src/commands/project/start.ts
+var { CaporalValidator } = caporalCore;
+function streamToBuffer(stream) {
+  return new Promise((resolve) => {
+    const response = [];
+    if (process.platform.includes("win")) {
+      stream.once("resume", () => {
+        setTimeout(() => {
+          resolve(Buffer.concat(response));
+        }, 2e3);
+      });
+    }
+    stream.on("data", (chunk) => response.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(response)));
+  });
+}
+async function create({ args: cmdArgs, options }) {
+  const { name } = cmdArgs;
+  const { localResourceFolder } = options;
+  const machine2 = new DockerMachine();
+  const networkName = `${name}-network`, databaseName = `${name}-db`, port = await getport({ port: options.port }), publicHost = `http://localhost:${port}`, apiUrl = `${publicHost}/api`, functionApiUrl = apiUrl.replace("localhost", "host.docker.internal");
+  if (options.port.toString() != port.toString() && options.port != 4500) {
+    console.info(`Port ${options.port} already in use, the port ${port} will be used instead.`);
+  }
+  let identifier = "spica";
+  let password = "spica";
+  let args = [];
+  if (options.apiOptions) {
+    const filename = path8.resolve(options.apiOptions);
+    const rawFile = fs8.readFileSync(filename, { encoding: "utf8" });
+    let apiOptions = {};
+    try {
+      apiOptions = JSON.parse(rawFile);
+      identifier = apiOptions["passport-default-identity-identifier"] || identifier;
+      password = apiOptions["passport-default-identity-password"] || password;
+    } catch (error) {
+      throw Error(`Error while parsing api-options file. ${error}`);
+    }
+    for (const [key, value] of Object.entries(apiOptions)) {
+      args.push(`--${key}=${value}`);
+    }
+  }
+  const persistentPath = "/var/data";
+  args = [
+    ...args,
+    // If user defines some of these values in the apiOptions file, they will be overwriten.
+    // We should explain this behavior to users on the documentation or somewhere else.
+    `--database-name=${name}`,
+    `--database-replica-set=${name}`,
+    `--database-uri="mongodb://${databaseName}-0,${databaseName}-1,${databaseName}-2"`,
+    `--public-url=${apiUrl}`,
+    `--function-api-url=${functionApiUrl}`,
+    `--master-key=${name}`,
+    `--persistent-path=${persistentPath}`
+  ];
+  const foundNetworks = await machine2.listNetworks({
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  });
+  const foundContainers = await machine2.listContainers({
+    all: true,
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  });
+  if ((foundNetworks.length || foundContainers.length) && !options.force) {
+    console.warn(
+      `There is a instance with name ${name} already exists.
+Use --force to delete existing one.`
+    );
+    return;
+  }
+  if (options.force && (foundNetworks.length || foundContainers.length)) {
+    await spin({
+      text: `Shutting down and removing the previous containers, networks${!options.retainVolumes ? ", and volumes" : ""}.`,
+      op: async () => {
+        await Promise.all(
+          foundContainers.map(async (containerInfo) => {
+            const container = await machine2.getContainer(containerInfo.Id);
+            await container.remove({
+              v: true,
+              // Remove volumes attached to the container
+              force: true
+              // Stop if the container running
+            });
+            return new Promise((resolve) => setTimeout(resolve, 1e3));
+          })
+        );
+        await Promise.all(foundNetworks.map((network2) => machine2.getNetwork(network2.Id).remove()));
+        if (!options.retainVolumes) {
+          const foundVolumes = (await machine2.listVolumes({
+            filters: JSON.stringify({ label: [`namespace=${name}`] })
+          })).Volumes;
+          await Promise.all(foundVolumes.map((volume) => machine2.getVolume(volume.Name).remove()));
+        }
+      }
+    });
+  }
+  await spin({
+    text: `Pulling images.`,
+    op: async (spinner) => {
+      const images = [
+        {
+          image: "spicaengine/api",
+          tag: options.imageVersion.toString()
+        },
+        {
+          image: "spicaengine/panel",
+          tag: options.imageVersion.toString()
+        },
+        {
+          image: "mongo",
+          tag: options.mongoVersion.toString()
+        },
+        {
+          image: "nginx",
+          tag: "latest"
+        }
+      ];
+      const imagesToPull = [];
+      for (const image of images) {
+        const exists = await machine2.doesImageExist(image.image, image.tag);
+        if (exists && options.imagePullPolicy == "if-not-present") {
+          continue;
+        }
+        imagesToPull.push(image);
+      }
+      let pulled = 0;
+      function increasePulledCount() {
+        pulled++;
+        spinner.text = `Pulling images (${pulled}/${imagesToPull.length})`;
+      }
+      return Promise.all(
+        imagesToPull.map(
+          (image) => machine2.pullImage(image.image, image.tag).then(() => increasePulledCount())
+        )
+      );
+    }
+  });
+  const network = await spin({
+    text: `Creating a network named ${networkName}.`,
+    op: machine2.createNetwork({
+      Name: networkName,
+      Labels: { namespace: name }
+    })
+  });
+  async function createMongoDB(instanceIndex) {
+    const container = await machine2.createContainer({
+      Image: `mongo:${options.mongoVersion.toString()}`,
+      name: `${databaseName}-${instanceIndex}`,
+      Cmd: ["--replSet", name, "--bind_ip_all"],
+      Labels: { namespace: name },
+      HostConfig: {
+        RestartPolicy: {
+          Name: options.restart ? "unless-stopped" : "no"
+        },
+        Mounts: [
+          {
+            Source: `${name}-db-${instanceIndex}`,
+            Type: "volume",
+            Target: "/data/db",
+            VolumeOptions: {
+              DriverConfig: {
+                Name: "local",
+                Options: {}
+              },
+              NoCopy: false,
+              Labels: { namespace: name }
+            }
+          }
+        ]
+      }
+    });
+    await network.connect({ Container: container.id });
+    return container.start();
+  }
+  const databaseReplicas = Number(options.databaseReplicas);
+  let shell = "mongo";
+  async function detectShell(container) {
+    const probe = await container.exec({
+      Cmd: ["sh", "-c", "command -v mongosh || command -v mongo || true"],
+      AttachStdout: true,
+      AttachStderr: true
+    });
+    const res = await probe.start({});
+    const out = (await streamToBuffer(res)).toString().trim();
+    if (!out) throw new Error("no mongo shell available in container");
+    return out.split("/").pop();
+  }
+  await spin({
+    text: `Creating database containers (1/${databaseReplicas})`,
+    op: async (spinner) => {
+      for (let index = 0; index < databaseReplicas; index++) {
+        await createMongoDB(index);
+        spinner.text = `Creating database containers (${index + 1}/${databaseReplicas})`;
+      }
+    }
+  });
+  await spin({
+    text: "Waiting the database containers to become ready.",
+    op: async (spinner) => {
+      const replSetConfig = JSON.stringify({
+        _id: name,
+        members: new Array(databaseReplicas).fill(0).map((_, index) => {
+          return { _id: index, host: `${databaseName}-${index}` };
+        })
+      });
+      const firstContainer = machine2.getContainer(`${databaseName}-0`);
+      const detected = await detectShell(firstContainer);
+      if (detected) shell = detected;
+      const initiateReplication = async (reconfig = false) => {
+        spinner.text = "Initiating replication between database containers.";
+        const exec = await firstContainer.exec({
+          Cmd: [
+            shell,
+            "admin",
+            "--eval",
+            reconfig ? `rs.reconfig(${replSetConfig}, { force: true })` : `rs.initiate(${replSetConfig})`
+          ],
+          AttachStderr: true,
+          AttachStdout: true
+        });
+        const result = await exec.start({});
+        const buffer = await streamToBuffer(result);
+        return buffer.toString();
+      };
+      let output = await initiateReplication();
+      let retry = 0, maxRetries = 5, wait = 1e3;
+      while (retry < maxRetries) {
+        retry++;
+        if (output.indexOf("ECONNREFUSED") != -1) {
+          output = await initiateReplication();
+        } else {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, wait));
+        spinner.text = `Initiating replication between database containers. Retrying ${retry}`;
+      }
+      if (output.indexOf("already initialized") != -1) {
+        output = await initiateReplication(true);
+      }
+      if (output.indexOf("ok: 1") == -1) {
+        return Promise.reject(output);
+      }
+    }
+  });
+  await spin({
+    text: "Waiting for the replica set to become ready.",
+    op: async () => {
+      const firstContainer = machine2.getContainer(`${databaseName}-0`);
+      for (let i = 0; i < 15; i++) {
+        const exec = await firstContainer.exec({
+          Cmd: [shell, "admin", "--eval", "rs.status()"],
+          AttachStderr: true,
+          AttachStdout: true
+        });
+        const output = await exec.start({});
+        const response = await streamToBuffer(output);
+        const responseText = response.toString("utf-8");
+        if (responseText.indexOf("ok: 1") > -1 && responseText.indexOf("stateStr: 'PRIMARY'") > -1) {
+          return Promise.resolve();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      return Promise.reject("Replica Set did not become ready in 30 seconds.");
+    }
+  });
+  let binds = [];
+  if (localResourceFolder) {
+    fs8.mkdirSync(localResourceFolder, { recursive: true });
+    binds = [`${localResourceFolder}:${persistentPath}/representatives`];
+  }
+  await spin({
+    text: `Creating spica containers (0/2)`,
+    op: async (spinner) => {
+      const client = await machine2.createContainer({
+        Image: `spicaengine/panel:${options.imageVersion}`,
+        name: `${name}-spica`,
+        Env: ["BASE_URL=/"],
+        Labels: { namespace: name },
+        HostConfig: {
+          RestartPolicy: {
+            Name: options.restart ? "unless-stopped" : "no"
+          }
+        }
+      });
+      await network.connect({ Container: client.id });
+      await client.start();
+      spinner.text = `Creating spica containers (1/2)`;
+      const api = await machine2.createContainer({
+        Image: `spicaengine/api:${options.imageVersion}`,
+        name: `${name}-api`,
+        Cmd: args,
+        Labels: { namespace: name },
+        ExposedPorts: { "80/tcp": {} },
+        HostConfig: {
+          RestartPolicy: {
+            Name: options.restart ? "unless-stopped" : "no"
+          },
+          Mounts: [
+            {
+              Target: persistentPath,
+              Source: `${name}-api`,
+              Type: "volume",
+              VolumeOptions: {
+                NoCopy: false,
+                Labels: { namespace: name },
+                DriverConfig: {
+                  Name: "local",
+                  Options: {}
+                }
+              }
+            }
+          ],
+          Binds: binds
+        }
+      });
+      await network.connect({ Container: api.id });
+      await api.start();
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      spinner.text = `Creating spica containers (2/2)`;
+    }
+  });
+  await spin({
+    text: `Creating an ingress to route traffic.`,
+    op: async () => {
+      const proxy = await machine2.createContainer({
+        Image: `nginx:latest`,
+        name: `${name}-ingress`,
+        HostConfig: {
+          PortBindings: { "80/tcp": [{ HostPort: port.toString() }] },
+          RestartPolicy: {
+            Name: options.restart ? "unless-stopped" : "no"
+          }
+        },
+        Labels: { namespace: name }
+      });
+      await network.connect({ Container: proxy.id });
+      await proxy.start();
+      const nginxConfig = `
+      upstream ${name}-api {
+        server ${name}-api;
+      }
+      upstream ${name}-spica {
+        server ${name}-spica;
+      }
+      server {
+        listen       80;
+        server_name  localhost;
+
+        location ~ ^/api/?(.*) {
+          proxy_pass http://${name}-api/$1$is_args$args;
+          proxy_set_header Host $host;
+          proxy_set_header X-Forwarded-Proto $scheme;
+          proxy_set_header X-Forwarded-Port $server_port;
+          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+          proxy_http_version 1.1;
+          proxy_set_header Upgrade $http_upgrade;
+          proxy_set_header Connection "Upgrade";
+        }
+
+        location ~ ^/?(.*) {
+          proxy_pass http://${name}-spica/$1$is_args$args;
+          proxy_set_header Host $host;
+          proxy_set_header X-Forwarded-Proto $scheme;
+          proxy_set_header X-Forwarded-Port $server_port;
+          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+          proxy_http_version 1.1;
+          proxy_set_header Upgrade $http_upgrade;
+          proxy_set_header Connection "Upgrade";
+        }
+      }
+      `;
+      const exec = await proxy.exec({
+        Cmd: ["bash", "-c", `echo '${nginxConfig}' > /etc/nginx/conf.d/default.conf`],
+        AttachStderr: true,
+        AttachStdout: true
+      });
+      const output = await exec.start({});
+      await streamToBuffer(output);
+      await proxy.restart();
+    }
+  });
+  console.info(`
+Spica ${name} is serving on ${publicHost}.
+Open your browser on ${publicHost} to login.
+
+Identitifer: ${identifier}
+Password: ${password}
+  `);
+  if (options.open) {
+    await open(`${publicHost}/spica`);
+  }
+}
+function start_default(program2) {
+  return program2.command("project start", "Start a project on your local machine.").argument("<name>", "Name of the project.", { validator: projectName }).option(
+    "-p, --port",
+    "Port that ingress will serve on. If not specified an open port will be used.",
+    {
+      default: "4500",
+      required: true,
+      validator: CaporalValidator.NUMBER
+    }
+  ).option("--image-version", "Version of the spica to run.", {
+    default: "latest",
+    validator: CaporalValidator.STRING
+  }).option("--mongo-version", "Version of the MongoDB image to run.", {
+    default: "8.0",
+    validator: CaporalValidator.STRING
+  }).option("-o, --open", "Open project authorization page after creation.", {
+    validator: CaporalValidator.BOOLEAN
+  }).option("-f, --force", "Remove the existing project if exists with same name.", {
+    validator: CaporalValidator.BOOLEAN
+  }).option("--retain-volumes", "When false, the existing data will be removed.", {
+    default: true,
+    validator: CaporalValidator.BOOLEAN
+  }).option("--restart", "Restart failed containers if exits unexpectedly.", {
+    default: true,
+    validator: CaporalValidator.BOOLEAN
+  }).option(
+    "--image-pull-policy",
+    "Image pull policy. when 'if-not-present' images won't be pulled in if already present on the docker.",
+    {
+      default: "if-not-present",
+      validator: ["if-not-present", "default"]
+    }
+  ).option("--database-replicas", "Number of database nodes.", {
+    default: "1",
+    validator: CaporalValidator.NUMBER
+  }).option(
+    "--api-options",
+    "Absolute file path that contains api key options as key value in JSON format.",
+    {
+      validator: CaporalValidator.STRING
+    }
+  ).option(
+    "--local-resource-folder",
+    `Absolute local folder path to sync resources from and to Spica. 
+      WARNING: During container startup, the initial synchronization from Spica to the local folder will remove local files (bucket, function, etc.) and insert Spica ones.
+      Files that aren't managed by Spica will remain(.git, .gitignore etc.).
+      Backup or commit necessary files before starting.`,
+    {
+      validator: projectLocalResourceFolder
+    }
+  ).action(create);
+}
+
+// apps/cli/src/commands/project/sync.ts
+import caporalCore2 from "@caporal/core";
+import { bold as bold3, green as green3, red as red3 } from "colorette";
+import lodash from "lodash";
+var { CaporalValidator: CaporalValidator2 } = caporalCore2;
+var { isEqual } = lodash;
+var IGNORE_ERRORS;
+var CONCURRENCY_LIMIT;
+async function sync({
+  options: {
+    sourceUrl,
+    sourceApikey,
+    targetUrl,
+    targetApikey,
+    modules,
+    bucketIds,
+    functionIds,
+    apikeyIds,
+    policyIds,
+    envVarIds,
+    dryRun,
+    ignoreErrors,
+    concurrencyLimit
+  }
+}) {
+  IGNORE_ERRORS = ignoreErrors;
+  CONCURRENCY_LIMIT = concurrencyLimit;
+  const sourceService = httpService.create({
+    baseUrl: sourceUrl.toString(),
+    authorization: `APIKEY ${sourceApikey}`
+  });
+  const targetService = httpService.create({
+    baseUrl: targetUrl.toString(),
+    authorization: `APIKEY ${targetApikey}`
+  });
+  modules = modules.toString().split(",").map((m) => m.trim());
+  const coreSynchronizers = [
+    FunctionSynchronizer,
+    BucketSynchronizer,
+    ApikeySynchronizer,
+    PolicySynchronizer,
+    EnvironmentVariableSynchronizer
+  ];
+  const synchronizers = [];
+  for (const Ctor of coreSynchronizers) {
+    const synchronizer = new Ctor(sourceService, targetService, {
+      bucketIds: transformIDs(bucketIds),
+      functionIds: transformIDs(functionIds),
+      apikeyIds: transformIDs(apikeyIds),
+      policyIds: transformIDs(policyIds),
+      envVarIds: transformIDs(envVarIds)
+    });
+    const subSynchronizers = await synchronizer.initialize().catch((e) => {
+      return Promise.reject(returnErrorMessage(e));
+    });
+    synchronizers.push(synchronizer);
+    synchronizers.push(...subSynchronizers);
+  }
+  for (const name of modules) {
+    const moduleSynchronizers = synchronizers.filter((s) => s.moduleName == name);
+    for (const synchronizer of moduleSynchronizers) {
+      const { insertions, updations, deletions } = await synchronizer.analyze().catch((e) => {
+        return Promise.reject(returnErrorMessage(e));
+      });
+      if (dryRun) {
+        printActions({
+          insertions,
+          updations,
+          deletions,
+          field: synchronizer.primaryField,
+          moduleName: synchronizer.getDisplayableModuleName()
+        });
+      } else {
+        try {
+          await synchronizer.synchronize();
+        } catch (error) {
+          Promise.reject(returnErrorMessage(error));
+        }
+        console.log(
+          `
+${synchronizer.getDisplayableModuleName()} synchronization has been completed!`.toUpperCase()
+        );
+      }
+    }
+  }
+}
+function sync_default(program2) {
+  return program2.command(
+    "project sync",
+    `Synchronize selected module objects between two spica instances(local or remote).
+${red3(
+      "ATTENTION"
+    )}: Source and target instance versions must be minimum v0.9.19 and for the best results both instance versions should be the same. 
+Also this command will perform adding, overwriting and removing actions of the target instance and it's irreversible. 
+We highly recommend you to use --dry-run=true and check the changes that will be applied before start.`
+  ).option("--source-url", "API address of the instance where objects will be synchronized from", {
+    required: true,
+    validator: CaporalValidator2.STRING
+  }).option("--source-apikey", "Apikey of the instance where objects will be synchronized from", {
+    required: true,
+    validator: CaporalValidator2.STRING
+  }).option("--target-url", "API address of the instance where objects will be synchronized to", {
+    required: true,
+    validator: CaporalValidator2.STRING
+  }).option(
+    "--target-apikey",
+    "API address of the instance where objects will be synchronized to",
+    {
+      required: true,
+      validator: CaporalValidator2.STRING
+    }
+  ).option(
+    "--modules",
+    `Module names of objects that will be synchronized. Available modules: ${green3(
+      availableSyncModules.join(",")
+    )}`,
+    {
+      required: true,
+      validator: validateSyncModules
+    }
+  ).option("--bucket-ids <ids>", "Buckets that will be synchronized (comma-separated)", {
+    required: false,
+    validator: validateSyncIds
+  }).option("--function-ids <ids>", "Functions that will be synchronized (comma-separated)", {
+    required: false,
+    validator: validateSyncIds
+  }).option("--apikey-ids <ids>", "Apikeys that will be synchronized (comma-separated)", {
+    required: false,
+    validator: validateSyncIds
+  }).option("--policy-ids <ids>", "Policies that will be synchronized (comma-separated)", {
+    required: false,
+    validator: validateSyncIds
+  }).option(
+    "--env-var-ids <ids>",
+    "Environment variables that will be synchronized (comma-separated)",
+    {
+      required: false,
+      validator: validateSyncIds
+    }
+  ).option("--dry-run", "Shows the changes that will be applied to the target instance.", {
+    default: false
+  }).option(
+    "--ignore-errors",
+    "Set true if you don't want to interrupt sync process because of failed requests.",
+    {
+      default: false
+    }
+  ).option(
+    "--concurrency-limit",
+    "Increase(if you want to speed up), decrease(if you get some error like ECONNRESET) this value to adjust how many parallel requests that will be sent to the target instance",
+    {
+      default: 100,
+      validator: CaporalValidator2.NUMBER
+    }
+  ).action(sync);
+}
+var ResourceGroupComparisor = class {
+  constructor(sources, targets, uniqueField = "_id", ignoredFields = []) {
+    this.sources = sources;
+    this.targets = targets;
+    this.uniqueField = uniqueField;
+    this.ignoredFields = ignoredFields;
+    this.existings = [];
+    this.existingIds = [];
+    this.existings = targets.filter(
+      (target) => sources.some((source) => source[this.uniqueField] == target[this.uniqueField])
+    );
+    this.existingIds = this.existings.map((existing) => existing[this.uniqueField]);
+  }
+  updations() {
+    const updations = [];
+    for (const existing of this.existings) {
+      const source = this.sources.find(
+        (source2) => source2[this.uniqueField] == existing[this.uniqueField]
+      );
+      if (this.ignoredFields.length) {
+        this.ignoredFields.forEach((field) => {
+          delete source[field];
+          delete existing[field];
+        });
+      }
+      if (!isEqual(source, existing)) {
+        updations.push(source);
+      }
+    }
+    return updations;
+  }
+  insertions() {
+    return this.sources.filter((source) => this.existingIds.indexOf(source[this.uniqueField]) == -1);
+  }
+  deletions() {
+    return this.targets.filter((target) => this.existingIds.indexOf(target[this.uniqueField]) == -1);
+  }
+};
+var FunctionSynchronizer = class {
+  constructor(sourceService, targetService, options) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.options = options;
+    this.moduleName = "function";
+    this.primaryField = "name";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  async initialize() {
+    const synchronizers = [];
+    const sourceFns = await getFilteredResources(
+      "function",
+      this.sourceService,
+      this.options.functionIds
+    );
+    for (const fn of sourceFns) {
+      synchronizers.push(
+        new FunctionDependencySynchronizer(this.sourceService, this.targetService, fn)
+      );
+    }
+    synchronizers.push(new FunctionIndexSynchronizer(this.sourceService, this.targetService));
+    return synchronizers;
+  }
+  async analyze() {
+    console.log();
+    let sourceFns = await spin({
+      text: "Fetching functions from source instance",
+      op: () => getFilteredResources("function", this.sourceService, this.options.functionIds)
+    });
+    const targetFns = await spin({
+      text: "Fetching functions from target instance",
+      op: () => getFilteredResources("function", this.targetService, this.options.functionIds)
+    });
+    const decider = new ResourceGroupComparisor(sourceFns, targetFns);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map(
+      (fn) => () => this.targetService.post("function", fn).catch(
+        (e) => handleRejection({
+          action: "insert",
+          e,
+          objectName: this.moduleName + " " + fn.name
+        })
+      )
+    );
+    await spinUntilPromiseEnd(insertPromiseFactories, "Inserting functions to the target instance");
+    const updatePromiseFactories = this.updations.map(
+      (fn) => () => this.targetService.put(`function/${fn._id}`, fn).catch(
+        (e) => handleRejection({
+          action: "update",
+          e,
+          objectName: this.moduleName + " " + fn.name
+        })
+      )
+    );
+    await spinUntilPromiseEnd(updatePromiseFactories, "Updating target instance functions");
+    const deletePromiseFactories = this.deletions.map(
+      (fn) => () => this.targetService.delete(`function/${fn._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: this.moduleName + " " + fn.name,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(deletePromiseFactories, "Deleting target instance functions");
+  }
+  getDisplayableModuleName() {
+    return this.moduleName;
+  }
+};
+var FunctionDependencySynchronizer = class {
+  constructor(sourceService, targetService, fn) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.fn = fn;
+    this.moduleName = "function";
+    this.subModuleName = "dependency";
+    this.primaryField = "name";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    const deleteTypes = (deps) => deps.map((d) => {
+      delete d.types;
+      return d;
+    });
+    const sourceDeps = await this.sourceService.get(`function/${this.fn._id}/dependencies`).then(deleteTypes);
+    const targetDeps = await this.targetService.get(`function/${this.fn._id}/dependencies`).then(deleteTypes).catch((e) => {
+      if (isNotFoundException(e)) {
+        return [];
+      }
+      return Promise.reject(e.data);
+    });
+    const decider = new ResourceGroupComparisor(sourceDeps, targetDeps, "name");
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const promiseFactories = [];
+    const insertBody = [...this.insertions, ...this.updations].reduce(
+      (acc, dep) => {
+        const depName = `${dep.name}@${dep.version.slice(1)}`;
+        acc.name.push(depName);
+        return acc;
+      },
+      { name: [] }
+    );
+    if (insertBody.name.length) {
+      promiseFactories.push(
+        () => this.targetService.post(`function/${this.fn._id}/dependencies`, insertBody).catch((e) => {
+          handleRejection({
+            action: "insert",
+            e,
+            objectName: this.getDisplayableModuleName()
+          });
+        })
+      );
+    }
+    const deletePromiseFactories = this.deletions.map(
+      (dep) => () => this.targetService.delete(`function/${this.fn._id}/dependencies/${dep.name}`).catch(
+        (e) => handleRejection({
+          action: "update",
+          e,
+          objectName: this.getDisplayableModuleName()
+        })
+      )
+    );
+    if (deletePromiseFactories.length) {
+      promiseFactories.push(...deletePromiseFactories);
+    }
+    return spinUntilPromiseEnd(
+      promiseFactories,
+      `Updating function '${this.fn.name}' dependencies`
+    );
+  }
+  getDisplayableModuleName() {
+    return `${this.moduleName} '${this.fn.name}' ${this.subModuleName}`;
+  }
+};
+var FunctionIndexSynchronizer = class {
+  constructor(sourceService, targetService) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.moduleName = "function";
+    this.subModuleName = "index";
+    this.primaryField = "name";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    const sourceFns = await this.sourceService.get("function");
+    const sourceFnIndexes = await Promise.all(
+      sourceFns.map(
+        (fn) => this.sourceService.get(`function/${fn._id}/index`).then((res) => {
+          return {
+            _id: fn._id,
+            name: fn.name,
+            index: res.index
+          };
+        })
+      )
+    );
+    const targetFnIndexes = await Promise.all(
+      sourceFns.map(
+        (fn) => this.targetService.get(`function/${fn._id}/index`).then((res) => {
+          return {
+            _id: fn._id,
+            name: fn.name,
+            index: res.index
+          };
+        }).catch((e) => {
+          if (isNotFoundException(e)) {
+            return false;
+          }
+          return Promise.reject(e.data);
+        })
+      )
+    ).then((indexes) => indexes.filter(Boolean));
+    const decider = new ResourceGroupComparisor(sourceFnIndexes, targetFnIndexes);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  synchronize() {
+    const promiseFactories = [...this.insertions, ...this.updations].map(
+      (fn) => () => this.targetService.post(`function/${fn._id}/index`, { index: fn.index }).catch(
+        (e) => handleRejection({
+          action: "insert",
+          objectName: this.getDisplayableModuleName() + " " + fn.name,
+          e
+        })
+      )
+    );
+    return spinUntilPromiseEnd(
+      promiseFactories,
+      "Writing indexes to the target instance functions"
+    );
+  }
+  getDisplayableModuleName() {
+    return this.moduleName + " " + this.subModuleName;
+  }
+};
+var BucketDataSynchronizer = class {
+  constructor(sourceService, targetService, bucket) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.bucket = bucket;
+    this.moduleName = "bucket-data";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+    this.primaryField = this.bucket.primary;
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    const params = {
+      localize: false
+    };
+    const sourceData = await this.sourceService.get(`bucket/${this.bucket._id}/data`, {
+      params
+    });
+    const targetData = await this.targetService.get(`bucket/${this.bucket._id}/data`, {
+      params
+    }).catch((e) => {
+      if (isNotFoundException(e)) {
+        return [];
+      }
+      return Promise.reject(e.data);
+    });
+    const decider = new ResourceGroupComparisor(sourceData, targetData);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map(
+      (data) => () => this.targetService.post(`bucket/${this.bucket._id}/data`, data).catch(
+        (e) => handleRejection({
+          action: "insert",
+          objectName: this.getDisplayableModuleName() + " " + data[this.primaryField],
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(
+      insertPromiseFactories,
+      `Inserting bucket ${this.bucket.title} data to the target instance`
+    );
+    const updatePromiseFactories = this.updations.map(
+      (data) => () => this.targetService.put(`bucket/${this.bucket._id}/data/${data._id}`, data).catch(
+        (e) => handleRejection({
+          action: "update",
+          e,
+          objectName: this.getDisplayableModuleName() + " " + data[this.primaryField]
+        })
+      )
+    );
+    await spinUntilPromiseEnd(
+      updatePromiseFactories,
+      `Updating bucket ${this.bucket.title} data on the target instance`
+    );
+    const deletePromiseFactories = this.deletions.map(
+      (data) => () => this.targetService.delete(`bucket/${this.bucket._id}/data/${data._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: this.getDisplayableModuleName() + " " + data[this.primaryField],
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(
+      deletePromiseFactories,
+      `Deleting bucket ${this.bucket.title} data from the target instance`
+    );
+  }
+  getDisplayableModuleName() {
+    return `${this.moduleName} '${this.bucket.title}'`;
+  }
+};
+var BucketSynchronizer = class {
+  constructor(sourceService, targetService, options) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.options = options;
+    this.moduleName = "bucket";
+    this.primaryField = "title";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  async initialize() {
+    const synchronizers = [];
+    const sourceBuckets = await getFilteredResources(
+      "bucket",
+      this.sourceService,
+      this.options.bucketIds
+    );
+    for (const bucket of sourceBuckets) {
+      synchronizers.push(
+        new BucketDataSynchronizer(this.sourceService, this.targetService, bucket)
+      );
+    }
+    return synchronizers;
+  }
+  async analyze() {
+    console.log();
+    const sourceBuckets = await spin({
+      text: "Fetching buckets from source instance",
+      op: () => getFilteredResources("bucket", this.sourceService, this.options.bucketIds)
+    });
+    const targetBuckets = await spin({
+      text: "Fetching buckets from target instance",
+      op: () => getFilteredResources("bucket", this.targetService, this.options.bucketIds)
+    });
+    const decider = new ResourceGroupComparisor(sourceBuckets, targetBuckets);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map(
+      (bucket) => () => this.targetService.post("bucket", bucket).catch(
+        (e) => handleRejection({
+          action: "insert",
+          objectName: this.getDisplayableModuleName() + " " + bucket.title,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(insertPromiseFactories, "Inserting buckets to the target instance");
+    const updatePromiseFactories = this.updations.map(
+      (bucket) => () => this.targetService.put(`bucket/${bucket._id}`, bucket).catch(
+        (e) => handleRejection({
+          action: "update",
+          objectName: this.getDisplayableModuleName() + " " + bucket.title,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(updatePromiseFactories, "Updating buckets on the target instance");
+    const deletePromiseFactories = this.deletions.map(
+      (bucket) => () => this.targetService.delete(`bucket/${bucket._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: bucket.title,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(deletePromiseFactories, "Deleting bucket from the target instance");
+  }
+  getDisplayableModuleName() {
+    return this.moduleName;
+  }
+};
+var ApikeySynchronizer = class {
+  constructor(sourceService, targetService, options) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.options = options;
+    this.moduleName = "apikey";
+    this.primaryField = "name";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    console.log();
+    const sourceApikeys = await spin({
+      text: "Fetching apikeys from source instance",
+      op: () => getFilteredResources("passport/apikey", this.sourceService, this.options.apikeyIds, true)
+    });
+    const targetApikeys = await spin({
+      text: "Fetching apikeys from target instance",
+      op: () => getFilteredResources("passport/apikey", this.targetService, this.options.apikeyIds, true)
+    });
+    const decider = new ResourceGroupComparisor(sourceApikeys, targetApikeys);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map((apikey) => () => {
+      const insertRejectionHandler = (e) => handleRejection({
+        action: "insert",
+        objectName: this.getDisplayableModuleName() + " " + apikey.name,
+        e
+      });
+      const policies = [...apikey.policies];
+      delete apikey.policies;
+      const apikeyInsertPromise = this.targetService.post("passport/apikey", apikey).catch((e) => insertRejectionHandler(e));
+      return apikeyInsertPromise.then(() => {
+        const policyAttachPromises = policies.map(
+          (policy) => this.targetService.put(`passport/apikey/${apikey._id}/policy/${policy}`).catch((e) => insertRejectionHandler(e))
+        );
+        return Promise.all(policyAttachPromises);
+      });
+    });
+    await spinUntilPromiseEnd(insertPromiseFactories, "Inserting apikeys to the target instance");
+    const updatePromiseFactories = this.updations.map((apikey) => () => {
+      const rejectionHandler = (e) => {
+        handleRejection({
+          action: "update",
+          objectName: this.getDisplayableModuleName() + " " + apikey.name,
+          e
+        });
+      };
+      const policies = [...apikey.policies];
+      delete apikey.policies;
+      const apikeyDeletePromise = this.targetService.delete(`passport/apikey/${apikey._id}`).catch((e) => rejectionHandler(e));
+      const apikeyInsertPromise = apikeyDeletePromise.then(
+        () => this.targetService.post(`passport/apikey`, apikey).catch((e) => rejectionHandler(e))
+      );
+      return apikeyInsertPromise.then(() => {
+        const policyAttachPromises = policies.map(
+          (policy) => this.targetService.put(`passport/apikey/${apikey._id}/policy/${policy}`).catch((e) => rejectionHandler(e))
+        );
+        return Promise.all(policyAttachPromises);
+      });
+    });
+    await spinUntilPromiseEnd(updatePromiseFactories, "Updating apikeys on the target instance");
+    const deletePromiseFactories = this.deletions.map(
+      (apikey) => () => this.targetService.delete(`passport/apikey/${apikey._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: apikey.name,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(deletePromiseFactories, "Deleting apikeys from the target instance");
+  }
+  getDisplayableModuleName() {
+    return this.moduleName;
+  }
+};
+var PolicySynchronizer = class {
+  constructor(sourceService, targetService, options) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.options = options;
+    this.moduleName = "policy";
+    this.primaryField = "name";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    console.log();
+    const sourcePolicies = await spin({
+      text: "Fetching policies from source instance",
+      op: () => getFilteredResources("passport/policy", this.sourceService, this.options.policyIds, true)
+    });
+    const targetPolicies = await spin({
+      text: "Fetching policies from target instance",
+      op: () => getFilteredResources("passport/policy", this.targetService, this.options.policyIds, true)
+    });
+    const decider = new ResourceGroupComparisor(sourcePolicies, targetPolicies);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map((policy) => () => {
+      delete policy.system;
+      return this.targetService.post("passport/policy", policy).catch(
+        (e) => handleRejection({
+          action: "insert",
+          objectName: this.getDisplayableModuleName() + " " + policy.name,
+          e
+        })
+      );
+    });
+    await spinUntilPromiseEnd(insertPromiseFactories, "Inserting policies to the target instance");
+    const updatePromiseFactories = this.updations.map((policy) => () => {
+      delete policy.system;
+      return this.targetService.put(`passport/policy/${policy._id}`, policy).catch(
+        (e) => handleRejection({
+          action: "update",
+          objectName: this.getDisplayableModuleName() + " " + policy.name,
+          e
+        })
+      );
+    });
+    await spinUntilPromiseEnd(updatePromiseFactories, "Updating policies on the target instance");
+    const deletePromiseFactories = this.deletions.map(
+      (policy) => () => this.targetService.delete(`passport/policy/${policy._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: policy.name,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(deletePromiseFactories, "Deleting policies from the target instance");
+  }
+  getDisplayableModuleName() {
+    return this.moduleName;
+  }
+};
+var EnvironmentVariableSynchronizer = class {
+  constructor(sourceService, targetService, options) {
+    this.sourceService = sourceService;
+    this.targetService = targetService;
+    this.options = options;
+    this.moduleName = "env-var";
+    this.primaryField = "key";
+    this.insertions = [];
+    this.updations = [];
+    this.deletions = [];
+  }
+  initialize() {
+    return Promise.resolve([]);
+  }
+  async analyze() {
+    console.log();
+    const sourceEnvVars = await spin({
+      text: "Fetching env vars from source instance",
+      op: () => getFilteredResources("env-var", this.sourceService, this.options.envVarIds)
+    });
+    const targetEnvVars = await spin({
+      text: "Fetching env vars from target instance",
+      op: () => getFilteredResources("env-var", this.targetService, this.options.envVarIds)
+    });
+    const decider = new ResourceGroupComparisor(sourceEnvVars, targetEnvVars);
+    this.insertions = decider.insertions();
+    this.updations = decider.updations();
+    this.deletions = decider.deletions();
+    return {
+      insertions: this.insertions,
+      updations: this.updations,
+      deletions: this.deletions
+    };
+  }
+  async synchronize() {
+    console.log();
+    const insertPromiseFactories = this.insertions.map(
+      (envVar) => () => this.targetService.post("env-var", envVar).catch(
+        (e) => handleRejection({
+          action: "insert",
+          objectName: this.getDisplayableModuleName() + " " + envVar.key,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(insertPromiseFactories, "Inserting env vars to the target instance");
+    const updatePromiseFactories = this.updations.map(
+      (envVar) => () => this.targetService.put(`env-var/${envVar._id}`, envVar).catch(
+        (e) => handleRejection({
+          action: "update",
+          objectName: this.getDisplayableModuleName() + " " + envVar.key,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(updatePromiseFactories, "Updating env vars on the target instance");
+    const deletePromiseFactories = this.deletions.map(
+      (envVar) => () => this.targetService.delete(`env-var/${envVar._id}`).catch(
+        (e) => handleRejection({
+          action: "delete",
+          objectName: envVar.key,
+          e
+        })
+      )
+    );
+    await spinUntilPromiseEnd(deletePromiseFactories, "Deleting env vars from the target instance");
+  }
+  getDisplayableModuleName() {
+    return this.moduleName;
+  }
+};
+function printActions({ insertions, updations, deletions, field, moduleName }) {
+  const joinActions = (actions) => {
+    const MAX_LINES = 20;
+    actions = actions.map((a) => `- ${a[field]}`);
+    if (actions.length > MAX_LINES) {
+      actions = actions.slice(0, MAX_LINES);
+      actions.push("...more");
+    }
+    return actions.join("\n");
+  };
+  console.log();
+  console.log(`----- ${moduleName.toUpperCase()} -----`);
+  console.log(
+    `
+* Found ${bold3(insertions.length)} objects to ${bold3("insert")}: 
+${joinActions(insertions)}`
+  );
+  console.log(
+    `
+* Found ${bold3(updations.length)} objects to ${bold3("update")}: 
+${joinActions(updations)}`
+  );
+  console.log(
+    `
+* Found ${bold3(deletions.length)} objects to ${bold3("delete")}: 
+${joinActions(deletions)}`
+  );
+}
+function spinUntilPromiseEnd(promiseFactories, label) {
+  if (!promiseFactories.length) {
+    return;
+  }
+  return spin({
+    text: label,
+    op: async (spinner) => {
+      let progress = 0;
+      let count = 0;
+      const concurrency = Math.min(promiseFactories.length, CONCURRENCY_LIMIT);
+      let batchPromises = [];
+      for (let i = 0; i < promiseFactories.length; i++) {
+        batchPromises.push(promiseFactories[i]);
+        if (batchPromises.length == concurrency || i == promiseFactories.length - 1) {
+          await Promise.all(batchPromises.map((b) => b()));
+          batchPromises = [];
+        }
+        count++;
+        progress = 100 / promiseFactories.length * count;
+        spinner.text = `${label} (%${Math.round(progress)})`;
+      }
+      return;
+    }
+  });
+}
+function handleRejection({ action, objectName, e }) {
+  const errorMessage = returnErrorMessage(e);
+  const msg = `
+Failed to ${action} ${bold3(objectName)}.
+${errorMessage}`;
+  if (IGNORE_ERRORS) {
+    return console.warn(msg);
+  } else {
+    return Promise.reject(msg);
+  }
+}
+function returnErrorMessage(e) {
+  return e.data ? e.data.message || e.data : e;
+}
+function isNotFoundException(e) {
+  const code = 404;
+  return e.status == code || e.statusCode == code || e.data && e.data.statusCode == code;
+}
+async function getFilteredResources(path9, service, ids, paginate) {
+  const res = await service.get(path9);
+  const resources = paginate ? res.data : res;
+  return ids ? resources.filter((resource) => ids.includes(resource._id)) : resources;
+}
+function transformIDs(ids) {
+  return ids === "string" ? ids.split(",") : [];
+}
+
+// apps/cli/src/commands/project/upgrade.ts
+import caporalCore3 from "@caporal/core";
+var { CaporalValidator: CaporalValidator3 } = caporalCore3;
+async function upgrade({ args, options }) {
+  const name = args.name;
+  const desiredVersion = args.to;
+  const machine2 = new DockerMachine();
+  const projectContainers = await machine2.listContainers({
+    all: true,
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  });
+  if (!projectContainers.length) {
+    return console.error(`Project '${name}' does not exist.`);
+  }
+  const oldClient = projectContainers.find((c) => c.Image.startsWith("spicaengine/panel"));
+  if (!oldClient) {
+    return console.error(
+      "Unable to upgrade the version of the project. Make sure that it's running with no issue."
+    );
+  }
+  const oldApi = projectContainers.find((c) => c.Image.startsWith("spicaengine/api"));
+  if (!oldApi) {
+    return console.error(
+      "Unable to upgrade the version of the project. Make sure that it's running with no issue"
+    );
+  }
+  const oldClientVersion = await version(oldClient.Image);
+  if (!isVersionUpgrade(desiredVersion, oldClientVersion)) {
+    return console.error(
+      `Requested version(${desiredVersion}) is not greater than current version(${oldClientVersion}).`
+    );
+  }
+  const oldApiVersion = await version(oldApi.Image);
+  if (!isVersionUpgrade(desiredVersion, oldApiVersion)) {
+    return console.error(
+      `Requested version(${desiredVersion}) is greater than current version(${oldApiVersion}).`
+    );
+  }
+  await spin({
+    text: "Pulling images..",
+    op: async (spinner) => {
+      const images = [
+        {
+          image: "spicaengine/api",
+          tag: desiredVersion
+        },
+        {
+          image: "spicaengine/panel",
+          tag: desiredVersion
+        }
+      ];
+      images.push({
+        image: "spicaengine/migrate",
+        tag: desiredVersion
+      });
+      let pulled = 0;
+      function increasePulledCount() {
+        pulled++;
+        spinner.text = `Pulling images (${pulled}/${images.length})`;
+      }
+      return Promise.all(
+        images.map(
+          (image) => machine2.pullImage(image.image, image.tag).then(() => increasePulledCount())
+        )
+      );
+    }
+  });
+  const commands = oldApi ? oldApi.Command.split(" ") : [];
+  await spin({
+    text: "Shutting down and removing the old containers..",
+    op: async () => {
+      await Promise.all(
+        [oldClient, oldApi].map(async (containerInfo) => {
+          if (!containerInfo) {
+            return;
+          }
+          const container = await machine2.getContainer(containerInfo.Id);
+          await container.remove({
+            v: true,
+            // Remove volumes attached to the container
+            force: true
+            // Stop if the container running
+          });
+          return new Promise((resolve) => setTimeout(resolve, 1e3));
+        })
+      );
+    }
+  });
+  const network = await machine2.listNetworks({
+    filters: JSON.stringify({ label: [`namespace=${name}`] })
+  }).then(([networkInfo]) => machine2.getNetwork(networkInfo.Id));
+  await spin({
+    text: `Creating spica containers (0/2)`,
+    op: async (spinner) => {
+      const client = await machine2.createContainer({
+        Image: `spicaengine/panel:${desiredVersion}`,
+        name: `${name}-spica`,
+        Env: ["BASE_URL=/"],
+        Labels: { namespace: name },
+        HostConfig: {
+          RestartPolicy: {
+            Name: options.restart ? "unless-stopped" : "no"
+          }
+        }
+      });
+      await network.connect({ Container: client.id });
+      await client.start();
+      spinner.text = `Creating spica containers (1/2)`;
+      const api = await machine2.createContainer({
+        Image: `spicaengine/api:${desiredVersion}`,
+        name: `${name}-api`,
+        Cmd: commands,
+        Labels: { namespace: name },
+        ExposedPorts: { "80/tcp": {} },
+        HostConfig: {
+          RestartPolicy: {
+            Name: options.restart ? "unless-stopped" : "no"
+          },
+          Mounts: [
+            {
+              Target: "/var/data",
+              Source: `${name}-api`,
+              Type: "volume",
+              VolumeOptions: {
+                NoCopy: false,
+                Labels: { namespace: name },
+                DriverConfig: {
+                  Name: "local",
+                  Options: {}
+                }
+              }
+            }
+          ]
+        }
+      });
+      await network.connect({ Container: api.id });
+      await api.start();
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      spinner.text = `Creating spica containers (2/2)`;
+    }
+  });
+  await spin({
+    text: "Migrating existing data to the new version.",
+    op: async (_) => {
+      const existingMigrate = projectContainers.find(
+        (p) => p.Image.startsWith("spicaengine/migrate")
+      );
+      if (existingMigrate) {
+        await machine2.getContainer(existingMigrate.Id).remove();
+      }
+      const databaseUriCommand = commands.find((c) => c.startsWith("--database-uri="));
+      const databaseNameCommand = commands.find((c) => c.startsWith("--database-name="));
+      const migrate = await machine2.createContainer({
+        Image: `spicaengine/migrate:${desiredVersion}`,
+        name: `${name}-migrate`,
+        Labels: { namespace: name },
+        Cmd: [
+          `--from=${oldApiVersion}`,
+          `--to=${desiredVersion}`,
+          databaseUriCommand,
+          databaseNameCommand,
+          "--continue-if-versions-are-equal=true"
+        ],
+        HostConfig: {
+          RestartPolicy: {
+            Name: "on-failure",
+            MaximumRetryCount: 3
+          }
+        }
+      });
+      await network.connect({ Container: migrate.id });
+      await migrate.start();
+    }
+  });
+  console.info(`Project '${name}' version has been set to the version ${desiredVersion}.`);
+}
+function upgrade_default(program2) {
+  return program2.command("project upgrade", "Upgrade the version of existing local project.").argument("<name>", "Name of the project.", { validator: projectName }).argument("<to>", "Version of the spica.").option("--restart", "Restart failed containers if exits unexpectedly.", {
+    default: true,
+    validator: CaporalValidator3.BOOLEAN
+  }).action(upgrade);
+}
+
+// apps/cli/package.json
+var package_default = {
+  name: "@spica/cli",
+  version: "0.0.0-PLACEHOLDER",
+  type: "module",
+  exports: {
+    ".": {
+      types: "./index.ts",
+      default: "./dist/index.js"
+    },
+    "./src/commands/project/sync": {
+      types: "./src/commands/project/sync.ts",
+      default: "./dist/src/commands/project/sync.js"
+    },
+    "./src/compile": {
+      types: "./src/compile.ts",
+      default: "./dist/src/compile.js"
+    },
+    "./src/function/triggers/http/services": {
+      types: "./src/function/triggers/http/services/index.ts",
+      default: "./dist/src/function/triggers/http/services/index.js"
+    },
+    "./src/function/triggers": {
+      types: "./src/function/triggers/index.ts",
+      default: "./dist/src/function/triggers/index.js"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  bin: {
+    spica: "bin/spica"
+  },
+  dependencies: {
+    "@caporal/core": "^2.0.7",
+    axios: "^1.8.2",
+    colorette: "^2.0.20",
+    columnify: "^1.6.0",
+    cosmiconfig: "^9.0.0",
+    dockerode: "^4.0.4",
+    dotenv: "^16.4.7",
+    "get-port": "^7.1.0",
+    jsonpath: "^1.1.1",
+    open: "^10.1.0",
+    ora: "^8.2.0",
+    "pretty-ms": "^9.2.0",
+    semver: "^7.7.1",
+    typescript: "^5.7.3",
+    yaml: "^2.7.1"
+  },
+  devDependencies: {
+    "@types/dockerode": "^3.3.34",
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^22.10.7",
+    "@types/semver": "^7.5.8"
+  }
+};
+
+// apps/cli/index.ts
+var { program } = caporalCore4;
+function run(argv) {
+  program.version(package_default.version).name("spica").bin("spica").description("Command line interface for spica.");
+  apply_default(program);
+  delete_default(program);
+  orm_default(program);
+  ls_default(program);
+  remove_default(program);
+  set_default(program);
+  switch_default(program);
+  orm_default2(program);
+  ls_default2(program);
+  remove_default2(program);
+  start_default(program);
+  sync_default(program);
+  upgrade_default(program);
+  return program.run(argv);
+}
+export {
+  run
+};