Cómo relaciono 2 tablas con nodejs

Lo que deseas realizar lo puedes hacer usando una referencia a tu colección profesor en tu colección asignatura.

PROBLEMA

Se desea establecer una relación 1:n entre 2 colecciones de MongoDB, usando Mongoose como ODM. El campo id_profesor en la colección asignaturas se desea relacionar con el campo id en la colección profesor. La relación es tal que 1 asignatura puede tener n profesores.

SOLUCIÓN

Para lograr lo que te propones voy a darte algunas pautas o sugerencias sobre cómo escribir tus modelos

1. No uses id's hardcodeados, te sugiero que uses siempre el campo _id autogenerado por MongoDB para cada documento en una colección. Esto es realmente útil para evitar el tener que crear validadores tipo unique.
2. No uses como nombre de tu esquema la palabra tabla. Aunque puedes usarlo, lo ideal es que te acostumbres a llamar las cosas por su nombre representativo. En MongoDB no existen las tablas, existen las colecciones. Un esquema no es una tabla, tal vez se parezca por el hecho de tener campos que traducidos podrían considerarse columnas. Pero es que en realidad las colecciones en MongoDB son cosas bastante diferentes (y a la vez parecidas) a las tablas en una base de datos relacional. La conclusión aqui es: "llama a las cosas por su nombre".
3. Estudia todas las posibilidades que te ofrece Mongoose al asignar los tipos a un campo. En la documentación de Mongoose puedes encontrar cuáles son los tipos permitidos en un Schema. Se les conoce como SchemaTypes. Entre los que allí se mencionan se encuentra: Array, y es ese tipo el que nos permitirá realizar la relación (realmente el término es referencia, pero se puede usar tranquilamente el término relación).

Aclarados esos puntos, te describo cómo vas a realizar la referencia.

Normalmente, yo uso nombres bien sugerentes en mis archivos. Además, suelo programar usando la sintaxis de ES6, aquí usaré ambas y tu decides la que más convenga.

El modelo de profesor lo escribiremos en un archivo llamado profesor.model.js:

// ES6
import mongoose from 'mongoose';
// ES5
// var mongoose = require('mongoose');

// usaremos 'const', ya que el esquema no cambia, por lo tanto 'let' o 'var' no tienen sentido
// otra cosa que normalmente evito es declarar variables que no sean necesarias
// por ejemplo hacer 'var Schema = mongoose.Schema;' no tiene sentido para mi
// me parece un desperdicio de memoria

// para ES5 solo sustituye 'const' por 'var'

const profesorSchema = new mongoose.Schema({
    dni: {
        type: String,
        required: 'El campo DNI es requerido u obligatorio'
    },
    nombre: {
        type: String,
        required: 'El campo NOMBRE es requerido u obligatorio'
    },
    apel1: {
        type: String,
        required: 'El campo PRIMER APELLIDO es requerido u obligatorio'
    },
    apel2: {
        type: String,
    },
    stdio_max: {
        type: String
    }
});

// ahora ya podemos esportar nuestro modelo que se va a basar en el esquema recién creado
export default mongoose.model('Profesor', profesorSchema);
// ES5:
// module.exports = mongoose.model('Profesor', profesorSchema);

Con esto ya tenemos el modelo profesor, si lo detallas bien no he incluido el campo id. Como te comenté al principio, MongoDB se encarga de asignar un campo _id a cada documento que sea creado en la colección profesores. Y es éste campo _id el que vamos a referenciar en nuestro esquema asignatura.

Ahora crearemos el modelo asignatura, y lo haremos en un archivo llamado asignatura.model.js

// ES6
import mongoose from 'mongoose';

// ES5:
// var mongoose = require('mongoose');

const asignaturaSchema = new mongoose.Schema({
    nombre: {
        type: String,
        required: 'El campo NOMBRE es requerido u obligatorio'
    },
    profesores: [{
        id: {
            type: mongoose.Schema.ObjectId,
            ref: 'Profesor'
        }
    }],
    duracion_por_clase: {
        type: Number
    }
});

export default mongoose.model('Asignatura', asignaturaSchema);
// ES5:
// module.exports = mongoose.model('Asignatura', asignaturaSchema);

Con esto ya tenemos listo el modelo asignaturas.

Ahora vamos a explicar lo que estamos haciendo en el campo profesores:

1. El campo se llama profesores ya que contendrá una lista con todos los _id de los profesores que deseemos agregar a la asignatura.
2. El tipo de campo es una Array que contiene elementos tipo documento u objeto.
3. Cada elemento de nuestro Array tiene un campo llamado id cuyo tipo es mongoose.Schema.ObjectId, y que hace referencia al modelo Profesor.

Con esto ya tienes una relación 1:n de la colección asignaturas a la colección profesores.

Ahora, ¿cómo uso eso?

Sencillo, usamos el método populate de Mongoose.

Una forma de implementarlo sería la siguiente:

//Supongamos que accedemos a las asignaturas usando el siguiente endpoint: /api/asignaturas
import Asignatura from './asignatura.model';
// ES5:
// var Asignatura = require('./asignatura.model');

app.get('/api/asignaturas', (req, res, next) => {
    Asignatura.find((err, asignaturas) => {
        if(err) {
            return res.status(400).json({
                err: 'Error de servidor: ' + err.message
            });
        }
        return res.status(200).json(asignaturas);
    })
    .populate('profesores', 'nombre apel1 apel2');
});

Con esto, al requerir la lista de asignaturas, el método populate traerá además del campo _id, los campos nombre, apel1 y apel2.

Espero que esto sea lo que estabas buscando.

Creo que a nivel relacionar seria una relacion n a n ( un profesor puede tener mas de una asginatura y una asignatura puede ser impuesta por mas de un profesor ), de todas formas yo agregaria un array en la tabla profesor haciendo referencia al id de asignatura. asi creo que no deberias tener problemas

var mongoose = require('mongoose');
//Define a schema
var Schema = mongoose.Schema;
var tablaProfesores = new Schema({
   id:number,
   dni:string,
   nombre:string,
   apel1:string,
   apel2:string,
   stdio_max:string,
   id_asignatura:[type: number]

});