Estoy intentando crear un cargador de paquetes web que convierta un archivo que contiene una descripción de las estructuras de datos API en un conjunto de interfaces TypeScript.

En mi caso concreto, el archivo es JSON, pero esto debería ser irrelevante en última instancia: el archivo es solo una fuente compartida de datos que describe la interacción entre los servidores de aplicaciones web y los frontend. En mi MCVE a continuación, puede ver que el archivo JSON contiene un objeto vacío para subrayar cómo el tipo y el contenido del archivo no son importantes para el problema.

Mi intento actual informa dos errores (supongo que el segundo es causado por el primero):

[at-loader]: Child process failed to process the request:  Error: Could not find file: '/private/tmp/ts-loader/example.api'.

ERROR in ./example.api
Module build failed: Error: Final loader didn't return a Buffer or String

¿Cómo puedo generar código TypeScript usando un cargador de paquetes web?

package.json

{
  "name": "so-example",
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
    "build": "webpack"
  },
  "dependencies": {
    "awesome-typescript-loader": "^3.2.3",
    "typescript": "^2.6.1",
    "webpack": "^3.8.1"
  }
}

webpack.config.js

const path = require('path');

module.exports = {
  entry: './index.ts',
  output: {
    filename: 'output.js',
  },
  resolveLoader: {
    alias: {
      'my-own-loader': path.resolve(__dirname, "my-own-loader.js"),
    },
  },
  module: {
    rules: [
      {
        test: /\.api$/,
        exclude: /node_modules/,
        use: ["awesome-typescript-loader", "my-own-loader"],
      },
      {
        test: /\.tsx?$/,
        exclude: /node_modules/,
        loader: "awesome-typescript-loader",
      },
    ]
  },
};

my-own-loader.js

module.exports = function(source) {
  return `
interface DummyContent {
    name: string;
    age?: number;
}
`;
};

index.ts

import * as foo from './example';

console.log(foo);

ejemplo.api

{}

Reconozco que hay otras técnicas de generación de código. Por ejemplo, podría convertir mis archivos JSON a TypeScript con alguna herramienta de compilación y registrarlos. Estoy buscando una solución más dinámica.

my-own-loader.js no exporta json sino una cadena.

Eso es correcto, al igual que cargar un archivo de imagen no siempre exporta datos binarios, pero a veces genera una estructura de datos JavaScript que representa metadatos sobre la imagen.

¿Por qué necesita definir las interfaces mecanografiadas del archivo json? ¿Se utilizarían las interfaces para la compilación mecanografiada?

Si. Quiero importar un archivo que describa las estructuras de datos de mi API y genere automáticamente las interfaces TypeScript correspondientes. Tener un archivo compartido permite que el frontend (s) y el backend (s) siempre estén de acuerdo sobre qué datos estarán presentes.