@palmares/drizzle-engine/dist/src/model.cjs

This is the engine that wraps the hole drizzle interface in a way palmares can understand and have full control of

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/model.ts
var model_exports = {};
__export(model_exports, {
  models: () => models
});
module.exports = __toCommonJS(model_exports);
var import_core = require("@palmares/core");
var import_databases = require("@palmares/databases");
var models = (0, import_databases.adapterModels)({
  // eslint-disable-next-line ts/require-await
  translateOptions: /* @__PURE__ */ __name(async (_engine, modelName, options) => {
    const optionsWithConjunctiveIndexes = options;
    if (options.indexes) optionsWithConjunctiveIndexes.conjunctiveIndexes = options.indexes.map((index) => {
      const indexFields = index.fields.join("_");
      const indexAsCamel = indexFields.toLowerCase().replace(/(^([a-z]+))|([-_][a-z])/g, (group) => {
        const groupWithoutDash = group.replace(/[-_]/, "");
        const firstLetterUpper = groupWithoutDash[0].toUpperCase();
        return firstLetterUpper + groupWithoutDash.slice(1);
      });
      const indexFieldsForOnClause = index.fields.map((field) => `table.${field}`).join(", ");
      return `  ${modelName.slice(0, 1).toLowerCase() + modelName.slice(1)}${indexAsCamel}:  d.${index.unique ? "uniqueIndex" : "index"}('${options.tableName || modelName}_${indexFields}').on(${indexFieldsForOnClause})`;
    });
    return {
      ...options
    };
  }, "translateOptions"),
  translate: /* @__PURE__ */ __name(async (_engine, _modelName, _model, _fieldEntriesOfModel, _modelOptions, _customModelOptions, defaultTranslateCallback, _, __) => {
    const { options: translatedOptions, fields: translatedAttributes } = await defaultTranslateCallback();
    return {
      fields: translatedAttributes,
      options: translatedOptions
    };
  }, "translate"),
  afterModelsTranslation: /* @__PURE__ */ __name(async (engine, models2) => {
    let fileContent = "";
    const cwd = await import_core.std.os.cwd();
    const directoryName = import_core.std.files.dirname(engine.instance.output);
    const [folderName, locationToRequire] = await Promise.all([
      import_core.std.files.join(cwd, directoryName),
      import_core.std.files.join(cwd, engine.instance.output)
    ]);
    const imports = /* @__PURE__ */ new Set([
      `/** Automatically generated by @palmares/drizzle-engine on ${(/* @__PURE__ */ new Date()).toISOString()} */ 
`,
      `import * as d from '@palmares/drizzle-engine/${engine.instance.mainType === "postgres" ? "pg" : engine.instance.mainType === "sqlite" ? "sqlite" : "mysql"}-core';`
    ]);
    const relationships = /* @__PURE__ */ new Map();
    const tableType = engine.instance.mainType === "postgres" ? "pgTable" : engine.instance.mainType === "sqlite" ? "sqliteTable" : "mysqlTable";
    for (let i = 0; i < models2.length; i++) {
      const [modelName, model] = models2[i];
      for (const [relationModelName, relations] of Object.entries(model.options.relationships || {})) {
        relationships.set(relationModelName, {
          ...relationships.get(relationModelName) || {},
          ...relations
        });
      }
      const indexesOfModel = model.options.drizzleIndexes || [];
      const entriesOfFields = Object.entries(model.fields);
      const hasEnums = (model.options.enums || []).length > 0;
      if (model.options.imports) Array.from(model.options.imports || []).forEach((importString) => imports.add(importString));
      const modelContentStarter = hasEnums ? model.options.enums.map((enumColumn) => enumColumn).join("\n") + "\n\n" : "";
      const modelContent = `${modelContentStarter}export const ${modelName} = d.${tableType}('${model.options.tableName}', {
${entriesOfFields.map(([fieldName, fieldString]) => `  ${fieldName}: ${fieldString}`).join(",\n")}
}${indexesOfModel.length > 0 ? `, (table) => ({
${indexesOfModel.map((index) => `  ${index.fieldName}Idx: d.${index.unique ? "uniqueIndex" : "index"}('${model.options.tableName}_${index.databaseName}_idx').on(table.${index.fieldName})`).concat(model.options.conjunctiveIndexes || []).join(",\n")}
})` : ""});

`;
      fileContent += modelContent;
      models2[i] = [
        modelName,
        async () => {
          try {
            return Promise.resolve(require(import_core.std.files.getPathToFileURL(locationToRequire))[modelName]);
          } catch (e) {
            return (await import(import_core.std.files.getPathToFileURL(locationToRequire)))[modelName];
          }
        }
      ];
    }
    if (relationships.size > 0) imports.add(`import * as drzl from '@palmares/drizzle-engine/drizzle';`);
    for (const [modelName, relations] of relationships.entries()) {
      fileContent += `export const ${modelName}Relations = drzl.relations(${modelName}, (args) => ({
${Object.entries(relations).map(([relationName, relation]) => `  ${relationName}: ${relation}`).join(",\n")}
}));

`;
    }
    await import_core.std.files.makeDirectory(folderName);
    await import_core.std.files.writeFile(locationToRequire, `${Array.from(imports).join("\n")}

${fileContent}`);
    const modelsImported = await Promise.all(models2.map(async ([modelName, model]) => [
      modelName,
      await model()
    ]));
    return modelsImported;
  }, "afterModelsTranslation")
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  models
});