@smartive/graphql-magic 8.1.0 → 8.1.2

package/dist/cjs/index.cjs

@@ -30,15 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AliasGenerator: () => AliasGenerator,
-  CLIENT_CODEGEN: () => CLIENT_CODEGEN,
-  EMPTY_MODELS: () => EMPTY_MODELS,
   Enum: () => Enum,
   ForbiddenError: () => ForbiddenError,
-  GRAPHQL_CODEGEN: () => GRAPHQL_CODEGEN,
   GraphQLError: () => GraphQLError,
   ID_ALIAS: () => ID_ALIAS,
-  KNEXFILE: () => KNEXFILE,
-  KNEXFILE_PATH: () => KNEXFILE_PATH,
   MigrationGenerator: () => MigrationGenerator,
   NotFoundError: () => NotFoundError,
   PermissionError: () => PermissionError,
@@ -58,16 +53,12 @@ __export(src_exports, {
   displayField: () => displayField,
   document: () => document,
   enm: () => enm,
-  ensureFileExists: () => ensureFileExists,
   execute: () => execute,
   fieldType: () => fieldType,
   fields: () => fields,
-  findDeclarationInFile: () => findDeclarationInFile,
   generate: () => generate,
   generateDBModels: () => generateDBModels,
   generateDefinitions: () => generateDefinitions,
-  generateGraphqlApiTypes: () => generateGraphqlApiTypes,
-  generateGraphqlClientTypes: () => generateGraphqlClientTypes,
   generateKnexTables: () => generateKnexTables,
   generateMutations: () => generateMutations,
   generatePermissions: () => generatePermissions,
@@ -98,8 +89,6 @@ __export(src_exports, {
   getResolverNode: () => getResolverNode,
   getResolvers: () => getResolvers,
   getRootFieldNode: () => getRootFieldNode,
-  getSetting: () => getSetting,
-  getSettings: () => getSettings,
   getSimpleFields: () => getSimpleFields,
   getString: () => getString,
   getType: () => getType,
@@ -150,25 +139,19 @@ __export(src_exports, {
   not: () => not,
   object: () => object,
   ors: () => ors,
-  parseKnexfile: () => parseKnexfile,
-  parseModels: () => parseModels,
   printSchema: () => printSchema,
   printSchemaFromDocument: () => printSchemaFromDocument,
   printSchemaFromModels: () => printSchemaFromModels,
   queryRelations: () => queryRelations,
   queryResolver: () => queryResolver,
-  readLine: () => readLine,
   resolve: () => resolve,
   retry: () => retry,
   scalar: () => scalar,
-  staticEval: () => staticEval,
   summon: () => summon,
   summonByKey: () => summonByKey,
   summonByName: () => summonByName,
   typeToField: () => typeToField,
-  value: () => value,
-  visit: () => visit,
-  writeToFile: () => writeToFile
+  value: () => value
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -721,491 +704,6 @@ var generateKnexTables = (rawModels) => {
   return writer.toString();
 };
 
-// src/gqm/codegen.ts
-var import_cli = require("@graphql-codegen/cli");
-
-// src/gqm/settings.ts
-var import_fs = require("fs");
-var import_path = require("path");
-
-// src/gqm/readline.ts
-var import_readline = __toESM(require("readline"), 1);
-var readLine = (prompt) => {
-  const rl = import_readline.default.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve2) => {
-    rl.question(prompt, (answer) => {
-      rl.close();
-      resolve2(answer);
-    });
-  });
-};
-
-// src/gqm/templates.ts
-var EMPTY_MODELS = `
-import { RawModels, getModels } from '@smartive/graphql-magic';
-
-export const rawModels: RawModels = [
-  {
-    kind: 'entity',
-    name: 'User',
-    fields: []
-  },
-]
-
-export const models = getModels(rawModels);
-`;
-var GRAPHQL_CODEGEN = (path) => `
-overwrite: true
-schema: '${path}/schema.graphql'
-documents: null
-generates:
-  ${path}/api/index.ts:
-    plugins:
-      - 'typescript'
-      - 'typescript-resolvers'
-      - add:
-          content: "import { DateTime } from 'luxon'"
-config:
-  scalars:
-    DateTime: DateTime
-`;
-var CLIENT_CODEGEN = (path) => `
-schema: ${path}/schema.graphql
-documents: [ './src/**/*.ts', './src/**/*.tsx' ]
-generates:
-  ${path}/client/index.ts:
-    plugins:
-      - typescript
-      - typescript-operations
-      - typescript-compatibility
-
-config:
-  preResolveTypes: true # Simplifies the generated types
-  namingConvention: keep # Keeps naming as-is
-  nonOptionalTypename: true # Forces \`__typename\` on all selection sets
-  skipTypeNameForRoot: true # Don't generate __typename for root types
-  avoidOptionals: # Avoids optionals on the level of the field
-    field: true
-  scalars:
-    DateTime: string
-`;
-var KNEXFILE = `
-const config = {
-  client: 'postgresql',
-  connection: {
-    host: process.env.DATABASE_HOST,
-    database: process.env.DATABASE_NAME,
-    user: process.env.DATABASE_USER,
-    password: process.env.DATABASE_PASSWORD,
-  },
-} as const;
-
-export default config;
-`;
-
-// src/gqm/settings.ts
-var SETTINGS_PATH = ".gqmrc.json";
-var DEFAULTS = {
-  modelsPath: {
-    question: "What is the models path?",
-    defaultValue: "src/config/models.ts",
-    init: (path) => {
-      ensureFileExists(path, EMPTY_MODELS);
-    }
-  },
-  generatedFolderPath: {
-    question: "What is the path for generated stuff?",
-    defaultValue: "src/generated",
-    init: (path) => {
-      ensureFileExists(`${path}/.gitkeep`, "");
-      ensureFileExists(`${path}/db/.gitkeep`, "");
-      ensureFileExists(`${path}/api/.gitkeep`, "");
-      ensureFileExists(`${path}/client/.gitkeep`, "");
-      ensureFileExists(`graphql-codegen.yml`, GRAPHQL_CODEGEN(path));
-      ensureFileExists(`client-codegen.yml`, CLIENT_CODEGEN(path));
-    }
-  }
-};
-var initSetting = async (name2) => {
-  const { question, defaultValue, init } = DEFAULTS[name2];
-  const value2 = await readLine(`${question} (${defaultValue})`) || defaultValue;
-  init(value2);
-  return value2;
-};
-var initSettings = async () => {
-  const settings = {};
-  for (const name2 of Object.keys(DEFAULTS)) {
-    settings[name2] = await initSetting(name2);
-  }
-  saveSettings(settings);
-};
-var saveSettings = (settings) => {
-  writeToFile(SETTINGS_PATH, JSON.stringify(settings, null, 2));
-};
-var getSettings = async () => {
-  if (!(0, import_fs.existsSync)(SETTINGS_PATH)) {
-    await initSettings();
-  }
-  return JSON.parse((0, import_fs.readFileSync)(SETTINGS_PATH, "utf8"));
-};
-var getSetting = async (name2) => {
-  const settings = await getSettings();
-  if (!(name2 in settings)) {
-    settings[name2] = await initSetting(name2);
-    saveSettings(settings);
-  }
-  return settings[name2];
-};
-var ensureDirectoryExists = (filePath) => {
-  const dir = (0, import_path.dirname)(filePath);
-  if ((0, import_fs.existsSync)(dir)) {
-    return true;
-  }
-  ensureDirectoryExists(dir);
-  try {
-    (0, import_fs.mkdirSync)(dir);
-    return true;
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      return true;
-    }
-    throw err;
-  }
-};
-var ensureFileExists = (filePath, content) => {
-  if (!(0, import_fs.existsSync)(filePath)) {
-    console.info(`Creating ${filePath}`);
-    ensureDirectoryExists(filePath);
-    (0, import_fs.writeFileSync)(filePath, content);
-  }
-};
-var writeToFile = (filePath, content) => {
-  ensureDirectoryExists(filePath);
-  if ((0, import_fs.existsSync)(filePath)) {
-    const currentContent = (0, import_fs.readFileSync)(filePath, "utf-8");
-    if (content === currentContent) {
-    } else {
-      (0, import_fs.writeFileSync)(filePath, content);
-      console.info(`${filePath} updated`);
-    }
-  } else {
-    (0, import_fs.writeFileSync)(filePath, content);
-    console.info(`Created ${filePath}`);
-  }
-};
-
-// src/gqm/codegen.ts
-var generateGraphqlApiTypes = async () => {
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  await (0, import_cli.generate)({
-    overwrite: true,
-    schema: `${generatedFolderPath}/schema.graphql`,
-    documents: null,
-    generates: {
-      [`${generatedFolderPath}/api/index.ts`]: {
-        plugins: ["typescript", "typescript-resolvers", { add: { content: `import { DateTime } from 'luxon';` } }]
-      }
-    },
-    config: {
-      scalars: {
-        DateTime: "DateTime"
-      }
-    }
-  });
-};
-var generateGraphqlClientTypes = async () => {
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  await (0, import_cli.generate)({
-    schema: `${generatedFolderPath}/schema.graphql`,
-    documents: ["./src/**/*.ts", "./src/**/*.tsx"],
-    generates: {
-      [`${generatedFolderPath}/client/index.ts`]: {
-        plugins: ["typescript", "typescript-operations", "typescript-compatibility"]
-      }
-    },
-    config: {
-      preResolveTypes: true,
-      // Simplifies the generated types
-      namingConvention: "keep",
-      // Keeps naming as-is
-      nonOptionalTypename: true,
-      // Forces `__typename` on all selection sets
-      skipTypeNameForRoot: true,
-      // Don't generate __typename for root types
-      avoidOptionals: {
-        // Avoids optionals on the level of the field
-        field: true
-      },
-      scalars: {
-        DateTime: "string"
-      }
-    }
-  });
-};
-
-// src/gqm/parse-knexfile.ts
-var import_ts_morph4 = require("ts-morph");
-
-// src/gqm/static-eval.ts
-var import_ts_morph2 = require("ts-morph");
-
-// src/gqm/visitor.ts
-var import_ts_morph = require("ts-morph");
-var visit = (node, context, visitor2) => {
-  const kind = node?.getKind();
-  if (kind in visitor2) {
-    return visitor2[kind](node.asKindOrThrow(kind), context);
-  }
-  if ("unknown" in visitor2) {
-    return visitor2.unknown(node);
-  }
-  console.error(node.getText());
-  console.error(node.getParent().getText());
-  throw new Error(
-    `Cannot handle kind ${get(
-      Object.entries(import_ts_morph.SyntaxKind).find(([, val]) => val === kind),
-      0
-    )}`
-  );
-};
-
-// src/gqm/static-eval.ts
-var staticEval = (node, context) => visit(node, context, visitor);
-var visitor = {
-  undefined: () => void 0,
-  [import_ts_morph2.SyntaxKind.VariableDeclaration]: (node, context) => staticEval(node.getInitializer(), context),
-  [import_ts_morph2.SyntaxKind.ArrayLiteralExpression]: (node, context) => {
-    const values = [];
-    for (const value2 of node.getElements()) {
-      if (value2.isKind(import_ts_morph2.SyntaxKind.SpreadElement)) {
-        values.push(...staticEval(value2, context));
-      } else {
-        values.push(staticEval(value2, context));
-      }
-    }
-    return values;
-  },
-  [import_ts_morph2.SyntaxKind.ObjectLiteralExpression]: (node, context) => {
-    const result = {};
-    for (const property of node.getProperties()) {
-      Object.assign(result, staticEval(property, context));
-    }
-    return result;
-  },
-  [import_ts_morph2.SyntaxKind.StringLiteral]: (node) => node.getLiteralValue(),
-  [import_ts_morph2.SyntaxKind.PropertyAssignment]: (node, context) => ({
-    [node.getName()]: staticEval(node.getInitializer(), context)
-  }),
-  [import_ts_morph2.SyntaxKind.ShorthandPropertyAssignment]: (node, context) => ({
-    [node.getName()]: staticEval(node.getNameNode(), context)
-  }),
-  [import_ts_morph2.SyntaxKind.SpreadElement]: (node, context) => staticEval(node.getExpression(), context),
-  [import_ts_morph2.SyntaxKind.SpreadAssignment]: (node, context) => staticEval(node.getExpression(), context),
-  [import_ts_morph2.SyntaxKind.Identifier]: (node, context) => {
-    switch (node.getText()) {
-      case "undefined":
-        return void 0;
-      case "process":
-        return process;
-    }
-    const definitionNodes = node.getDefinitionNodes();
-    if (!definitionNodes.length) {
-      throw new Error(`No definition node found for identifier ${node.getText()}.`);
-    }
-    return staticEval(definitionNodes[0], context);
-  },
-  [import_ts_morph2.SyntaxKind.ParenthesizedExpression]: (node, context) => staticEval(node.getExpression(), context),
-  [import_ts_morph2.SyntaxKind.AsExpression]: (node, context) => staticEval(node.getExpression(), context),
-  [import_ts_morph2.SyntaxKind.ConditionalExpression]: (node, context) => staticEval(node.getCondition(), context) ? staticEval(node.getWhenTrue(), context) : staticEval(node.getWhenFalse(), context),
-  [import_ts_morph2.SyntaxKind.TrueKeyword]: () => true,
-  [import_ts_morph2.SyntaxKind.FalseKeyword]: () => false,
-  [import_ts_morph2.SyntaxKind.NumericLiteral]: (node) => node.getLiteralValue(),
-  [import_ts_morph2.SyntaxKind.CallExpression]: (node, context) => {
-    const method = staticEval(node.getExpression(), context);
-    const args2 = node.getArguments().map((arg) => staticEval(arg, context));
-    return method(...args2);
-  },
-  [import_ts_morph2.SyntaxKind.PropertyAccessExpression]: (node, context) => {
-    const target = staticEval(node.getExpression(), context);
-    const property = target[node.getName()];
-    if (typeof property === "function") {
-      if (Array.isArray(target)) {
-        switch (node.getName()) {
-          case "map":
-          case "flatMap":
-          case "includes":
-          case "some":
-          case "find":
-          case "filter":
-            return target[node.getName()].bind(target);
-        }
-      } else if (typeof target === "string") {
-        const name2 = node.getName();
-        switch (name2) {
-          case "slice":
-          case "toUpperCase":
-          case "toLowerCase":
-            return target[name2].bind(target);
-        }
-      }
-      throw new Error(`Cannot handle method ${node.getName()} on type ${typeof target}`);
-    }
-    return property;
-  },
-  [import_ts_morph2.SyntaxKind.ArrowFunction]: (node, context) => {
-    return (...args2) => {
-      const parameters = {};
-      let i = 0;
-      for (const parameter of node.getParameters()) {
-        parameters[parameter.getName()] = args2[i];
-        i++;
-      }
-      return staticEval(node.getBody(), { ...context, ...parameters });
-    };
-  },
-  [import_ts_morph2.SyntaxKind.Block]: (node, context) => {
-    for (const statement of node.getStatements()) {
-      return staticEval(statement, context);
-    }
-  },
-  [import_ts_morph2.SyntaxKind.CaseClause]: (node, context) => {
-    const statements = node.getStatements();
-    if (statements.length !== 1) {
-      console.error(node.getText());
-      throw new Error(`Can only handle code blocks with 1 statement.`);
-    }
-    return staticEval(statements[0], context);
-  },
-  [import_ts_morph2.SyntaxKind.DefaultClause]: (node, context) => {
-    const statements = node.getStatements();
-    if (statements.length !== 1) {
-      console.error(node.getText());
-      throw new Error(`Can only handle code blocks with exactly 1 statement.`);
-    }
-    return staticEval(statements[0], context);
-  },
-  [import_ts_morph2.SyntaxKind.ReturnStatement]: (node, context) => {
-    return staticEval(node.getExpression(), context);
-  },
-  [import_ts_morph2.SyntaxKind.SwitchStatement]: (node, context) => {
-    const value2 = staticEval(node.getExpression(), context);
-    let active = false;
-    for (const clause of node.getCaseBlock().getClauses()) {
-      switch (clause.getKind()) {
-        case import_ts_morph2.SyntaxKind.DefaultClause:
-          return staticEval(clause, context);
-        case import_ts_morph2.SyntaxKind.CaseClause: {
-          const caseClause = clause.asKindOrThrow(import_ts_morph2.SyntaxKind.CaseClause);
-          if (caseClause.getStatements().length && active) {
-            return staticEval(clause, context);
-          }
-          const caseValue = staticEval(caseClause.getExpression(), context);
-          if (value2 === caseValue) {
-            active = true;
-            if (caseClause.getStatements().length) {
-              return staticEval(clause, context);
-            }
-          }
-        }
-      }
-    }
-  },
-  [import_ts_morph2.SyntaxKind.Parameter]: (node, context) => context[node.getName()],
-  [import_ts_morph2.SyntaxKind.BinaryExpression]: (node, context) => {
-    switch (node.getOperatorToken().getKind()) {
-      case import_ts_morph2.SyntaxKind.EqualsEqualsEqualsToken:
-        return staticEval(node.getLeft(), context) === staticEval(node.getRight(), context);
-      case import_ts_morph2.SyntaxKind.BarBarToken:
-        return staticEval(node.getLeft(), context) || staticEval(node.getRight(), context);
-      default:
-        throw new Error(`Cannot handle operator of kind ${node.getOperatorToken().getKindName()}`);
-    }
-  },
-  [import_ts_morph2.SyntaxKind.SatisfiesExpression]: (node, context) => staticEval(node.getExpression(), context),
-  [import_ts_morph2.SyntaxKind.TemplateExpression]: (node, context) => node.getHead().getLiteralText() + node.getTemplateSpans().map((span) => staticEval(span.getExpression(), context) + staticEval(span.getLiteral(), context)).join(""),
-  [import_ts_morph2.SyntaxKind.TemplateTail]: (node) => node.getLiteralText(),
-  [import_ts_morph2.SyntaxKind.TemplateMiddle]: (node) => node.getLiteralText(),
-  [import_ts_morph2.SyntaxKind.PrefixUnaryExpression]: (node, context) => {
-    switch (node.getOperatorToken()) {
-      case import_ts_morph2.SyntaxKind.PlusToken:
-        return +staticEval(node.getOperand(), context);
-      case import_ts_morph2.SyntaxKind.MinusToken:
-        return -staticEval(node.getOperand(), context);
-      case import_ts_morph2.SyntaxKind.TildeToken:
-        return ~staticEval(node.getOperand(), context);
-      case import_ts_morph2.SyntaxKind.ExclamationToken:
-        return !staticEval(node.getOperand(), context);
-      case import_ts_morph2.SyntaxKind.PlusPlusToken:
-      case import_ts_morph2.SyntaxKind.MinusMinusToken:
-        throw new Error(`Cannot handle assignments.`);
-    }
-  },
-  [import_ts_morph2.SyntaxKind.ElementAccessExpression]: (node, context) => {
-    const target = staticEval(node.getExpression(), context);
-    const argument = staticEval(node.getArgumentExpression(), context);
-    return target[argument];
-  },
-  [import_ts_morph2.SyntaxKind.NoSubstitutionTemplateLiteral]: (node) => node.getLiteralValue()
-};
-
-// src/gqm/utils.ts
-var import_ts_morph3 = require("ts-morph");
-var findDeclarationInFile = (sourceFile, name2) => {
-  const syntaxList = sourceFile.getChildrenOfKind(import_ts_morph3.SyntaxKind.SyntaxList)[0];
-  if (!syntaxList) {
-    throw new Error("No SyntaxList");
-  }
-  const declaration = findDeclaration(syntaxList, name2);
-  if (!declaration) {
-    throw new Error(`No ${name2} declaration`);
-  }
-  return declaration;
-};
-var findDeclaration = (syntaxList, name2) => {
-  for (const variableStatement of syntaxList.getChildrenOfKind(import_ts_morph3.SyntaxKind.VariableStatement)) {
-    for (const declaration of variableStatement.getDeclarationList().getDeclarations()) {
-      if (declaration.getName() === name2) {
-        return declaration;
-      }
-    }
-  }
-};
-
-// src/gqm/parse-knexfile.ts
-var KNEXFILE_PATH = `knexfile.ts`;
-var parseKnexfile = async () => {
-  const project = new import_ts_morph4.Project({
-    manipulationSettings: {
-      indentationText: import_ts_morph4.IndentationText.TwoSpaces
-    }
-  });
-  ensureFileExists(KNEXFILE_PATH, KNEXFILE);
-  const sourceFile = project.addSourceFileAtPath(KNEXFILE_PATH);
-  const configDeclaration = findDeclarationInFile(sourceFile, "config");
-  const config = staticEval(configDeclaration, {});
-  return config;
-};
-
-// src/gqm/parse-models.ts
-var import_ts_morph5 = require("ts-morph");
-var parseModels = async () => {
-  const project = new import_ts_morph5.Project({
-    manipulationSettings: {
-      indentationText: import_ts_morph5.IndentationText.TwoSpaces
-    }
-  });
-  const modelsPath = await getSetting("modelsPath");
-  const sourceFile = project.addSourceFileAtPath(modelsPath);
-  const modelsDeclaration = findDeclarationInFile(sourceFile, "rawModels");
-  const rawModels = staticEval(modelsDeclaration, {});
-  const generatedFolderPath = await getSetting("generatedFolderPath");
-  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
-  return rawModels;
-};
-
 // src/migrations/generate.ts
 var import_code_block_writer2 = __toESM(require("code-block-writer"), 1);
 var import_knex_schema_inspector = require("knex-schema-inspector");
@@ -3261,15 +2759,10 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AliasGenerator,
-  CLIENT_CODEGEN,
-  EMPTY_MODELS,
   Enum,
   ForbiddenError,
-  GRAPHQL_CODEGEN,
   GraphQLError,
   ID_ALIAS,
-  KNEXFILE,
-  KNEXFILE_PATH,
   MigrationGenerator,
   NotFoundError,
   PermissionError,
@@ -3289,16 +2782,12 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   displayField,
   document,
   enm,
-  ensureFileExists,
   execute,
   fieldType,
   fields,
-  findDeclarationInFile,
   generate,
   generateDBModels,
   generateDefinitions,
-  generateGraphqlApiTypes,
-  generateGraphqlClientTypes,
   generateKnexTables,
   generateMutations,
   generatePermissions,
@@ -3329,8 +2818,6 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   getResolverNode,
   getResolvers,
   getRootFieldNode,
-  getSetting,
-  getSettings,
   getSimpleFields,
   getString,
   getType,
@@ -3381,23 +2868,17 @@ var printSchemaFromModels = (models) => printSchema((0, import_graphql5.buildAST
   not,
   object,
   ors,
-  parseKnexfile,
-  parseModels,
   printSchema,
   printSchemaFromDocument,
   printSchemaFromModels,
   queryRelations,
   queryResolver,
-  readLine,
   resolve,
   retry,
   scalar,
-  staticEval,
   summon,
   summonByKey,
   summonByName,
   typeToField,
-  value,
-  visit,
-  writeToFile
+  value
 });

package/dist/esm/index.d.ts

@@ -1,7 +1,6 @@
 export * from './api';
 export * from './client';
 export * from './db';
-export * from './gqm';
 export * from './migrations';
 export * from './models';
 export * from './permissions';

package/dist/esm/index.js

@@ -2,7 +2,6 @@
 export * from './api';
 export * from './client';
 export * from './db';
-export * from './gqm';
 export * from './migrations';
 export * from './models';
 export * from './permissions';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,iCAAiC;AAEjC,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,iCAAiC;AAEjC,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartive/graphql-magic",
-  "version": "8.1.0",
+  "version": "8.1.2",
   "description": "",
   "source": "src/index.ts",
   "type": "module",
@@ -28,7 +28,7 @@
     "build": "npm run build:esm && npm run build:cjs && npm run build:bin",
     "build:esm": "tsc",
     "build:cjs": "esbuild src/index.ts --bundle --platform=node --outdir=dist/cjs --out-extension:.js=.cjs --format=cjs --packages=external",
-    "build:bin": "esbuild src/bin/gqm.ts --bundle --platform=node --outdir=dist/bin --out-extension:.js=.cjs --format=cjs --packages=external"
+    "build:bin": "esbuild src/bin/gqm/gqm.ts --bundle --platform=node --outdir=dist/bin --out-extension:.js=.cjs --format=cjs --packages=external"
   },
   "bin": {
     "gqm": "dist/bin/gqm.cjs"
@@ -65,7 +65,7 @@
     "@smartive/eslint-config": "3.2.0",
     "@smartive/prettier-config": "3.1.2",
     "@types/jest": "29.5.4",
-    "@types/lodash": "4.14.197",
+    "@types/lodash": "4.14.198",
     "@types/luxon": "3.3.2",
     "@types/uuid": "9.0.3",
     "create-ts-index": "1.14.0",