index.ts

import type { 
  AdminForthResource, 
  IAdminForth,
  IHttpServer,
} from "adminforth";
import clone from 'clone';

import { AdminForthPlugin, AdminForthResourcePages, suggestIfTypo } from "adminforth";
import { PluginOptions } from "./types.js";
import { interpretResource, ActionCheckSource } from "adminforth";

export default class ForeignInlineShowPlugin extends AdminForthPlugin {
  foreignResource: AdminForthResource;
  options: PluginOptions;
  adminforth: IAdminForth;

  constructor(options: PluginOptions) {
    super(options, import.meta.url);
    this.options = options;
  }

  instanceUniqueRepresentation(pluginOptions: any) : string {
    return `${pluginOptions.foreignResourceId}`;
  }

  setupEndpoints(server: IHttpServer) {
    process.env.HEAVY_DEBUG && console.log(`🪲 ForeignInlineShowPlugin.setupEndpoints, registering: '/plugin/${this.pluginInstanceId}/get_resource'`);
    server.endpoint({
      method: 'POST',
      path: `/plugin/${this.pluginInstanceId}/get_resource`,
      handler: async ({ body, adminUser }) => {
        const resource = this.adminforth.config.resources.find((res) => this.options.foreignResourceId === res.resourceId);
        if (!resource) {
          return { error: `Resource ${this.options.foreignResourceId} not found` };
        }
        const resourceCopy = clone({ ...resource, plugins: undefined });

        if (this.options.modifyTableResourceConfig) {
          this.options.modifyTableResourceConfig(resourceCopy);
        }

        const { allowedActions } = await interpretResource(adminUser, resourceCopy, {}, ActionCheckSource.DisplayButtons, this.adminforth);

        return { 
          resource: { 
            ...resourceCopy,
            options: {
              ...resourceCopy.options,
              allowedActions,
            },
          }
        };
      }
    });
  }

  async modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
    super.modifyResourceConfig(adminforth, resourceConfig);
    this.adminforth = adminforth;

    this.foreignResource = adminforth.config.resources.find((resource) => resource.resourceId === this.options.foreignResourceId);
    if (!this.foreignResource) {
      const similar = suggestIfTypo(adminforth.config.resources.map((res) => res.resourceId), this.options.foreignResourceId);
      throw new Error(`ForeignInlineShowPlugin: Resource with ID "${this.options.foreignResourceId}" not found. ${similar ? `Did you mean "${similar}"?` : ''}`);
    }

    const newColumn = {
      name: `foreignInlineShow_${this.foreignResource.resourceId}`,
      label: 'Foreign Inline Show',
      virtual: true,
      showIn: {
        show: true,
        list: false,
        edit: false,
        create: false,
        filter: false,
      },
      components: {
        showRow: { 
          file: this.componentPath('InlineShow.vue'),
          meta: {
            ...this.options, 
            pluginInstanceId: this.pluginInstanceId
          }
        }
      },
    };

    if (this.options.placeInGroup?.name) {
      const fieldGroupTypes = [
        'fieldGroups',
        'createFieldGroups', 
        'editFieldGroups',
        'showFieldGroups'
      ] as const;

      let columnAdded = false;
      
      for (const groupType of fieldGroupTypes) {
        const targetGroup = resourceConfig.options?.[groupType]?.find(
          group => group.groupName === this.options.placeInGroup?.name
        );
        
        if (targetGroup) {
          if (this.options.placeInGroup.position < 0 || this.options.placeInGroup.position > targetGroup.columns.length) {
            throw new Error(`ForeignInlineShowPlugin: Invalid position ${this.options.placeInGroup?.position}. Must be between 0 and ${targetGroup.columns.length} for group "${this.options.placeInGroup?.name}"`);
          }

          if (!columnAdded) {
            const beforeColumnName = targetGroup.columns[this.options.placeInGroup.position - 1];
            const beforeColumnIndex = resourceConfig.columns.findIndex(
              col => col.name === beforeColumnName
            );
            resourceConfig.columns.splice(beforeColumnIndex + 1, 0, newColumn);
            columnAdded = true;
          }

          targetGroup.columns.splice(this.options.placeInGroup.position, 0, newColumn.name);
        }
      }
    } else {
      resourceConfig.columns.push(newColumn);
    }
  }
}