feat(tools-forecast-plugins-entity-fields): Added the name type options to allow custom field names

The options `idName`, `createdByName`, `createdAtName`, `updatedByName`, `updatedAtName`, and
`sequenceName` to allow users to specify custom data model field names

Author: sullivanpj

libs/contact/typescript/server/attachment/schema.4cast

@@ -11,6 +11,7 @@ generator js {
 
 plugin entityFields {
 provider = "@stormstack/tools-forecast-plugins-entity-fields"
+idFormat = "snowflake"
 }
 
 plugin crud {

tools/forecast/codegen/src/cli/plugin-manager.ts

@@ -178,191 +178,6 @@ export class PluginManager {
           );
         }
       }
-
-      /*for (const pluginInfo of this._plugins) {
-        let pluginModule: PluginModule;
-        try {
-          pluginModule = require(pluginModulePath);
-        } catch (err) {
-          ConsoleLogger.error(
-            `Unable to load plugin module ${pluginProvider}: ${pluginModulePath}, ${err}`
-          );
-          throw new ProcessingError(
-            `Unable to load plugin module ${pluginProvider}`
-          );
-        }
-
-        if (!pluginModule) {
-          ConsoleLogger.error(`Plugin provider ${pluginProvider} is missing`);
-          throw new ProcessingError(
-            `Plugin provider ${pluginProvider} is missing`
-          );
-        }
-        if (!pluginModule.generator) {
-          ConsoleLogger.error(
-            `Plugin provider ${pluginProvider} is missing a "generator" export`
-          );
-          throw new ProcessingError(
-            `Plugin provider ${pluginProvider} is missing a "generator" export`
-          );
-        }
-        if (!pluginModule.runner) {
-          ConsoleLogger.error(
-            `Plugin provider ${pluginProvider} is missing a "runner" export`
-          );
-          throw new ProcessingError(
-            `Plugin provider ${pluginProvider} is missing a "runner" export`
-          );
-        }
-
-        const dependencies = this.getPluginDependencies(pluginModule);
-        const pluginName = this.getPluginName(pluginModule, pluginProvider);
-        const options: PluginOptions = {
-          schemaPath: context.schemaPath,
-          name: pluginName
-        };
-
-        ConsoleLogger.debug(
-          `Preparing to load plugin:
-${JSON.stringify(options)}`
-        );
-
-        pluginDecl.fields.forEach(f => {
-          const value = getLiteral(f.value) ?? getLiteralArray(f.value);
-          if (value === undefined) {
-            throw new ProcessingError(
-              `${pluginName} Plugin: Invalid option value for ${f.name}`
-            );
-          }
-          options[f.name] = value;
-        });
-
-        const plugin = {
-          name: pluginName,
-          provider: pluginProvider,
-          dependencies,
-          options,
-          run: pluginModule.default as PluginFunction,
-          module: pluginModule
-        };
-
-        ConsoleLogger.debug(
-          `Loading plugin:
-${JSON.stringify(plugin)}`
-        );
-
-        plugins.push(plugin);
-
-        if (
-          pluginProvider === "@core/prisma" &&
-          typeof options.output === "string"
-        ) {
-          // record custom prisma output path
-          prismaOutput = resolvePath(options.output, options);
-        }
-      }
-
-      // make sure prerequisites are included
-      const corePlugins: Array<{
-        provider: string;
-        options?: Record<string, unknown>;
-      }> = [
-        { provider: "@core/prisma" },
-        { provider: "@core/model-meta" },
-        { provider: "@core/access-policy" }
-      ];
-
-      if (
-        getDataModels(context.schema).some(model =>
-          hasValidationAttributes(model)
-        )
-      ) {
-        // '@core/zod' plugin is auto-enabled if there're validation rules
-        corePlugins.push({
-          provider: "@plugins/zod",
-          options: { modelOnly: true }
-        });
-      }
-
-      // core plugins introduced by dependencies
-      plugins
-        .flatMap(p => p.dependencies)
-        .forEach(dep => {
-          if (dep.startsWith("@core/")) {
-            const existing = corePlugins.find(p => p.provider === dep);
-            if (existing) {
-              // reset options to default
-              existing.options = undefined;
-            } else {
-              // add core dependency
-              corePlugins.push({ provider: dep });
-            }
-          }
-        });
-
-      for (const corePlugin of corePlugins.reverse()) {
-        const existingIdx = plugins.findIndex(
-          p => p.provider === corePlugin.provider
-        );
-        if (existingIdx >= 0) {
-          // shift the plugin to the front
-          const existing = plugins[existingIdx];
-          plugins.splice(existingIdx, 1);
-          plugins.unshift(existing);
-        } else {
-          // synthesize a plugin and insert front
-          const pluginModule = require(this.getPluginModulePath(
-            corePlugin.provider
-          ));
-          const pluginName = this.getPluginName(
-            pluginModule,
-            corePlugin.provider
-          );
-          plugins.unshift({
-            name: pluginName,
-            provider: corePlugin.provider,
-            dependencies: [],
-            options: {
-              schemaPath: context.schemaPath,
-              name: pluginName,
-              ...corePlugin.options
-            },
-            run: pluginModule.default,
-            module: pluginModule
-          });
-        }
-      }
-
-      // check dependencies
-      for (const plugin of plugins) {
-        for (const dep of plugin.dependencies) {
-          if (!plugins.find(p => p.provider === dep)) {
-            ConsoleLogger.error(
-              `Plugin ${plugin.provider} depends on "${dep}" but it's not declared`
-            );
-            throw new ProcessingError(
-              `Plugin ${plugin.name}: ${plugin.provider} depends on "${dep}" but it's not declared`
-            );
-          }
-        }
-      }
-
-      let dmmf: DMMF.Document | undefined = undefined;
-      for (const { name, provider, run, options } of plugins) {
-        const start = Date.now();
-        await this.runPlugin(name, run, context, options, dmmf, warnings);
-        ConsoleLogger.log(
-          `✅ Plugin ${chalk.bold(name)} (${provider}) completed in ${
-            Date.now() - start
-          }ms`
-        );
-        if (provider === "@core/prisma") {
-          // load prisma DMMF
-          dmmf = await getDMMF({
-            datamodel: fs.readFileSync(prismaOutput, { encoding: "utf-8" })
-          });
-        }
-      }*/
     } else {
       ConsoleLogger.warn(
         "No plugins specified for this model. No processing will be performed (please ensure this is expected)."
@@ -400,31 +215,6 @@ ${JSON.stringify(plugin)}`
     return getLiteral<string>(providerField?.value);
   }
 
-  /*private async runPlugin(
-    name: string,
-    run: PluginFunction,
-    context: Context,
-    options: PluginOptions,
-    dmmf: DMMF.Document | undefined,
-    warnings: string[]
-  ) {
-    ConsoleLogger.info(`Executing plugin ${chalk.bold.cyan(name)}`);
-
-    try {
-      const result = Promise.resolve(run(context.model, options, dmmf, config));
-      if (Array.isArray(result)) {
-        warnings.push(...result);
-      }
-
-      ConsoleLogger.success("Plugin completed successfully");
-    } catch (err) {
-      ConsoleLogger.error("Plugin failed to complete");
-      ConsoleLogger.error(err);
-
-      throw err;
-    }
-  }*/
-
   private getPluginModulePath(provider: string) {
     let pluginModulePath = provider;
     if (pluginModulePath.startsWith("@stormstack/")) {
@@ -437,19 +227,6 @@ ${JSON.stringify(plugin)}`
       )}`;
     }
 
-    /*if (pluginModulePath.startsWith("@core/")) {
-      pluginModulePath = pluginModulePath.replace(
-        /^@core\//,
-        path.join(__dirname, "../../../forecast/plugins/")
-      );
-    }*/
-    /*if (pluginModulePath.startsWith("@plugins/")) {
-      pluginModulePath = pluginModulePath.replace(
-        /^@plugins\//,
-        path.join(__dirname, "../../../forecast/plugins/")
-      );
-    }*/
-
     return pluginModulePath;
   }
 
@@ -495,8 +272,10 @@ ${JSON.stringify(plugin)}`
     }
 
     if (!pluginModule) {
-      ConsoleLogger.error(`Plugin provider ${pluginProvider} is missing`);
-      throw new ProcessingError(`Plugin provider ${pluginProvider} is missing`);
+      ConsoleLogger.error(`Plugin provider ${pluginProvider} cannot be found`);
+      throw new ProcessingError(
+        `Plugin provider ${pluginProvider} cannot be found`
+      );
     }
 
     if (!pluginModule.name) {

tools/forecast/plugins/drizzle/src/index.ts

@@ -13,7 +13,6 @@ export const generator = new TemplateGenerator<DrizzlePluginOptions>();
 export const handle: PluginHandler<DrizzlePluginOptions> =
   createTemplatePluginHandler(
     {
-      templatePath: "templates/**",
       dataModelTemplatePath: "templates/schemas/**",
       enumTemplatePath: "templates/enums/**"
     },

tools/forecast/plugins/entity-fields/src/index.ts

@@ -17,28 +17,42 @@ import {
 import {
   ENTITY_CLASS_FIELDS,
   EntityFieldsPluginOptions,
-  IdentityFieldGenerator
+  IdFieldFormat
 } from "./types";
 
 export const name = "Entity Fields Extension";
 
 export const options = {
-  identityGenerator: IdentityFieldGenerator.SNOWFLAKE
+  idName: "id",
+  idFormat: IdFieldFormat.UUID,
+  createdAtName: "createdAt",
+  createdByName: "createdBy",
+  updatedAtName: "updatedAt",
+  updatedByName: "updatedBy",
+  sequenceName: "sequence"
 };
 
 export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
-  options: EntityFieldsPluginOptions,
+  {
+    idName,
+    idFormat,
+    createdAtName,
+    createdByName,
+    updatedAtName,
+    updatedByName,
+    sequenceName
+  }: EntityFieldsPluginOptions,
   context: Context
 ): Promise<Model> => {
   const model = context.model;
 
   getDataModels(model).forEach(dataModel => {
     let idField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "id".toLowerCase()
+      field => field.name?.toLowerCase() === idName.toLowerCase()
     );
     if (!idField) {
       idField = {
-        name: "id",
+        name: idName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],
@@ -104,17 +118,17 @@ export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
       addDefaultValue(
         model,
         idField,
-        options.identityGenerator ?? IdentityFieldGenerator.SNOWFLAKE,
+        idFormat ?? IdFieldFormat.UUID,
         "FunctionDecl"
       );
     }
 
     let createdAtField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "createdAt".toLowerCase()
+      field => field.name?.toLowerCase() === createdAtName.toLowerCase()
     );
     if (!createdAtField) {
       createdAtField = {
-        name: "createdAt",
+        name: createdAtName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],
@@ -133,11 +147,11 @@ export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
     }
 
     let createdByField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "createdBy".toLowerCase()
+      field => field.name?.toLowerCase() === createdByName.toLowerCase()
     );
     if (!createdByField) {
       createdByField = {
-        name: "createdBy",
+        name: createdByName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],
@@ -154,11 +168,11 @@ export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
     }
 
     let updatedAtField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "updatedAt".toLowerCase()
+      field => field.name?.toLowerCase() === updatedAtName.toLowerCase()
     );
     if (!updatedAtField) {
       updatedAtField = {
-        name: "updatedAt",
+        name: updatedAtName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],
@@ -177,11 +191,11 @@ export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
     }
 
     let updatedByField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "updatedBy".toLowerCase()
+      field => field.name?.toLowerCase() === updatedByName.toLowerCase()
     );
     if (!updatedByField) {
       updatedByField = {
-        name: "updatedBy",
+        name: updatedByName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],
@@ -198,11 +212,11 @@ export const extend: PluginExtend<EntityFieldsPluginOptions> = async (
     }
 
     let sequenceField: DataModelField = dataModel.fields.find(
-      field => field.name?.toLowerCase() === "sequence".toLowerCase()
+      field => field.name?.toLowerCase() === sequenceName.toLowerCase()
     );
     if (!sequenceField) {
       sequenceField = {
-        name: "sequence",
+        name: sequenceName,
         $container: dataModel,
         $type: "DataModelField",
         attributes: [],