@meghjs/cli 0.5.0 → 0.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
6
6
  exports.makeModel = makeModel;
7
7
  exports.makeService = makeService;
8
8
  exports.makeController = makeController;
9
+ exports.makeResource = makeResource;
9
10
  exports.makeConfig = makeConfig;
10
11
  exports.makeMiddleware = makeMiddleware;
11
12
  exports.makeDto = makeDto;
@@ -19,6 +20,9 @@ const names_1 = require("../utils/names");
19
20
  const project_1 = require("../utils/project");
20
21
  const stubs_1 = require("../utils/stubs");
21
22
  const migrate_1 = require("../commands/migrate");
23
+ const migration_schema_1 = require("./migration-schema");
24
+ const orm_model_1 = require("./orm-model");
25
+ const resource_1 = require("./resource");
22
26
  const DEFAULT_DIRS = {
23
27
  model: "models",
24
28
  service: "services",
@@ -57,40 +61,131 @@ function ensureDependency(file, render, label, projectRoot) {
57
61
  }
58
62
  write(file, render(), false, label, projectRoot);
59
63
  }
64
+ /**
65
+ * Create a Megh ORM model (or, with `orm`, a TypeORM entity). The model's
66
+ * columns come from the migration that creates its table, if there is one;
67
+ * otherwise it gets placeholder columns.
68
+ */
60
69
  function makeModel(name, opts = {}) {
61
70
  const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
62
71
  const n = (0, names_1.resolveName)(name, "Model");
63
72
  const file = path_1.default.join(targetDir(projectRoot, "model", n.dirs, opts.root), `${n.fileBase}.model.ts`);
64
- return write(file, renderModel(n.base, opts.orm), opts.force, "Model", projectRoot);
73
+ if (opts.orm)
74
+ return write(file, renderEntityModel(n.base), opts.force, "Model", projectRoot);
75
+ const { migrations } = (0, migrate_1.databasePaths)(projectRoot);
76
+ const rel = (p) => path_1.default.relative(projectRoot, p).split(path_1.default.sep).join("/");
77
+ const snake = (0, names_1.snakeCase)(n.base);
78
+ const candidates = opts.table ? [opts.table] : [(0, orm_model_1.pluralize)(snake), snake];
79
+ const schema = (0, migration_schema_1.readMigrationSchema)(migrations);
80
+ const table = candidates.map((t) => schema.get(t)).find((t) => t !== undefined);
81
+ if (table) {
82
+ write(file, (0, orm_model_1.renderOrmModel)(n.base, table), opts.force, "Model", projectRoot);
83
+ log_1.log.info(` ${table.columns.length} columns of "${table.name}" read from ${rel(migrations)}`);
84
+ }
85
+ else {
86
+ write(file, (0, orm_model_1.renderBlankOrmModel)(n.base, candidates[0]), opts.force, "Model", projectRoot);
87
+ log_1.log.info(` No migration creates "${candidates[0]}", so the columns are placeholders. ` +
88
+ `Create one with: megh make:migration create_${candidates[0]}_table`);
89
+ }
90
+ return file;
65
91
  }
66
- function renderModel(model, orm) {
67
- return (0, stubs_1.renderStub)(orm ? "models/entity-model.stub" : "models/basic-model.stub", {
68
- Model: model,
69
- table: (0, names_1.snakeCase)(model),
70
- });
92
+ function renderEntityModel(model) {
93
+ return (0, stubs_1.renderStub)("models/entity-model.stub", { Model: model, table: (0, names_1.snakeCase)(model) });
71
94
  }
95
+ /** The URL segment for a resource: `admin/BlogPost` → `admin/blog-posts`. */
96
+ function resourceRoute(dirs, base) {
97
+ // Singularize first so already-plural names (`Users`) become `/users`, not `/userses`.
98
+ return [...dirs, (0, orm_model_1.pluralRoute)((0, names_1.snakeCase)(base)).replace(/_/g, "-")].join("/");
99
+ }
100
+ const relPath = (projectRoot, file) => path_1.default.relative(projectRoot, file).split(path_1.default.sep).join("/");
72
101
  /**
73
- * Write a resource service for `model` at `serviceFile`, plus the model under
74
- * `src/models` if it does not exist yet, so the generated code compiles.
102
+ * Find the model for a resource: an existing model file is read as is;
103
+ * otherwise a Megh ORM model is built from the migration that creates its
104
+ * table. With `orm`, a missing model becomes a TypeORM placeholder entity.
105
+ * Throws when there is neither a model nor a migration.
75
106
  */
76
- function writeResourceService(projectRoot, serviceFile, serviceClass, model, orm, force, asDependency) {
77
- const m = (0, names_1.resolveName)(model, "Model");
78
- const modelFile = path_1.default.join(targetDir(projectRoot, "model", m.dirs), `${m.fileBase}.model.ts`);
79
- const render = () => (0, stubs_1.renderStub)(orm ? "services/orm-rest-service.stub" : "services/rest-service.stub", {
107
+ function resolveResourceModel(projectRoot, model, opts = {}) {
108
+ const name = (0, names_1.resolveName)(model, "Model");
109
+ const file = path_1.default.join(targetDir(projectRoot, "model", name.dirs), `${name.fileBase}.model.ts`);
110
+ const exists = fs_1.default.existsSync(file);
111
+ if (opts.orm && !exists)
112
+ return { name, file, create: renderEntityModel(name.base), typeorm: true };
113
+ const snake = (0, names_1.snakeCase)(name.base);
114
+ const tables = (0, migration_schema_1.readMigrationSchema)((0, migrate_1.databasePaths)(projectRoot).migrations);
115
+ const lookup = (candidates) => candidates.map((t) => (t ? tables.get(t) : undefined)).find((t) => t !== undefined);
116
+ if (exists) {
117
+ const source = fs_1.default.readFileSync(file, "utf8");
118
+ const declared = (0, resource_1.readModelSchema)(source).table;
119
+ const schema = (0, resource_1.readModelSchema)(source, lookup([opts.table, declared, (0, orm_model_1.pluralize)(snake), snake]));
120
+ return { name, file, schema, typeorm: opts.orm === true || schema.kind === "typeorm" };
121
+ }
122
+ const candidates = opts.table ? [opts.table] : [(0, orm_model_1.pluralize)(snake), snake];
123
+ const table = lookup(candidates);
124
+ if (!table) {
125
+ throw new errors_1.CliError(`There is no ${name.base} model (${relPath(projectRoot, file)}) and no migration creates the ` +
126
+ `"${candidates[0]}" table, so its columns are unknown. Create the table first:\n` +
127
+ ` megh make:migration create_${candidates[0]}_table\n` +
128
+ `or a model to fill in by hand: megh make:model ${name.base}`);
129
+ }
130
+ const create = (0, orm_model_1.renderOrmModel)(name.base, table);
131
+ return { name, file, create, schema: (0, resource_1.readModelSchema)(create, table), typeorm: false };
132
+ }
133
+ function renderResourceService(model, serviceFile, serviceClass) {
134
+ const vars = {
80
135
  ClassName: serviceClass,
136
+ Model: model.name.base,
137
+ modelVar: model.name.varName,
138
+ modelImport: importPath(serviceFile, model.file),
139
+ };
140
+ if (model.typeorm)
141
+ return (0, stubs_1.renderStub)("services/orm-rest-service.stub", vars);
142
+ return (0, stubs_1.renderStub)("services/model-service.stub", {
143
+ ...vars,
144
+ primaryKey: model.schema.primaryKey,
145
+ primaryKeyType: model.schema.primaryKeyType,
146
+ });
147
+ }
148
+ function renderResourceController(model, controllerFile, className, route, serviceFile, dtoFile) {
149
+ const m = model.name;
150
+ const vars = {
151
+ ClassName: className,
152
+ route,
81
153
  Model: m.base,
82
154
  modelVar: m.varName,
83
- modelImport: importPath(serviceFile, modelFile),
155
+ ServiceClass: `${m.base}Service`,
156
+ serviceVar: `${m.varName}Service`,
157
+ serviceImport: importPath(controllerFile, serviceFile),
158
+ };
159
+ if (model.typeorm)
160
+ return (0, stubs_1.renderStub)("controllers/resource-controller.stub", vars);
161
+ const numeric = model.schema.primaryKeyType === "number";
162
+ return (0, stubs_1.renderStub)("controllers/model-controller.stub", {
163
+ ...vars,
164
+ Plural: (0, names_1.pascalCase)((0, orm_model_1.pluralize)((0, names_1.snakeCase)(m.base))),
165
+ dtoImport: importPath(controllerFile, dtoFile),
166
+ primaryKeyType: numeric ? "number" : "string",
167
+ idArg: numeric ? "Number(id)" : "id",
84
168
  });
85
- if (asDependency)
86
- ensureDependency(serviceFile, render, "Service", projectRoot);
87
- else
88
- write(serviceFile, render(), force, "Service", projectRoot);
89
- ensureDependency(modelFile, () => renderModel(m.base, orm), "Model", projectRoot);
90
- if (orm && !(0, project_1.installedVersion)("@meghjs/data", projectRoot)) {
169
+ }
170
+ function renderDtoFor(model) {
171
+ const plural = (0, names_1.pascalCase)((0, orm_model_1.pluralize)((0, names_1.snakeCase)(model.name.base)));
172
+ return (0, resource_1.renderResourceDto)(model.name.base, plural, resourceRoute(model.name.dirs, model.name.base), model.schema);
173
+ }
174
+ function warnMissing(projectRoot, model) {
175
+ if (model.typeorm && !(0, project_1.installedVersion)("@meghjs/data", projectRoot)) {
91
176
  log_1.log.warn("The generated service uses @meghjs/data. Install it: npm install @meghjs/data typeorm");
92
177
  }
93
178
  }
179
+ function writeModelIfNew(projectRoot, model) {
180
+ if (model.create === undefined) {
181
+ log_1.log.info(` Model exists, reusing: ${relPath(projectRoot, model.file)}`);
182
+ return;
183
+ }
184
+ write(model.file, model.create, false, "Model", projectRoot);
185
+ const source = model.create.match(/table is created in (\S+?)\)/)?.[1];
186
+ if (source)
187
+ log_1.log.info(` Columns read from ${source}`);
188
+ }
94
189
  function makeService(name, opts = {}) {
95
190
  const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
96
191
  const n = (0, names_1.resolveName)(name, "Service");
@@ -99,7 +194,10 @@ function makeService(name, opts = {}) {
99
194
  throw new errors_1.CliError("A resource service needs a model: pass -m <model> (or --model <model>).");
100
195
  }
101
196
  if (opts.model) {
102
- writeResourceService(projectRoot, file, n.className, opts.model, opts.orm, opts.force, false);
197
+ const model = resolveResourceModel(projectRoot, opts.model, { orm: opts.orm });
198
+ write(file, renderResourceService(model, file, n.className), opts.force, "Service", projectRoot);
199
+ writeModelIfNew(projectRoot, model);
200
+ warnMissing(projectRoot, model);
103
201
  return file;
104
202
  }
105
203
  return write(file, (0, stubs_1.renderStub)("services/basic-service.stub", { ClassName: n.className }), opts.force, "Service", projectRoot);
@@ -111,23 +209,20 @@ function makeController(name, opts = {}) {
111
209
  if (fs_1.default.existsSync(file) && !opts.force) {
112
210
  throw new errors_1.CliError(`${file} already exists. Use -f or --force to overwrite it.`);
113
211
  }
114
- const route = [...n.dirs, `${n.fileBase}s`].join("/");
212
+ const route = resourceRoute(n.dirs, n.base);
115
213
  let content;
116
214
  if (opts.model) {
117
- const m = (0, names_1.resolveName)(opts.model, "Model");
118
- const serviceClass = `${m.base}Service`;
119
- const serviceFile = path_1.default.join(targetDir(projectRoot, "service", []), `${m.fileBase}.service.ts`);
120
- content = (0, stubs_1.renderStub)("controllers/resource-controller.stub", {
121
- ClassName: n.className,
122
- route,
123
- Model: m.base,
124
- modelVar: m.varName,
125
- ServiceClass: serviceClass,
126
- serviceVar: `${m.varName}Service`,
127
- serviceImport: importPath(file, serviceFile),
128
- });
215
+ const model = resolveResourceModel(projectRoot, opts.model, { orm: opts.orm });
216
+ const m = model.name;
217
+ const serviceFile = path_1.default.join(targetDir(projectRoot, "service", m.dirs), `${m.fileBase}.service.ts`);
218
+ const dtoFile = path_1.default.join(targetDir(projectRoot, "dto", m.dirs), `${m.fileBase}.dto.ts`);
219
+ content = renderResourceController(model, file, n.className, route, serviceFile, dtoFile);
129
220
  // Dependencies first, so a failure leaves no controller pointing at missing files.
130
- writeResourceService(projectRoot, serviceFile, serviceClass, opts.model, opts.orm, false, true);
221
+ if (!model.typeorm)
222
+ ensureDependency(dtoFile, () => renderDtoFor(model), "DTO", projectRoot);
223
+ ensureDependency(serviceFile, () => renderResourceService(model, serviceFile, `${m.base}Service`), "Service", projectRoot);
224
+ writeModelIfNew(projectRoot, model);
225
+ warnMissing(projectRoot, model);
131
226
  }
132
227
  else {
133
228
  const stub = opts.resource ? "controllers/rest-controller.stub" : "controllers/basic-controller.stub";
@@ -140,6 +235,47 @@ function makeController(name, opts = {}) {
140
235
  log_1.log.info(` Register it in your app: app.useControllers([..., ${n.className}])`);
141
236
  return file;
142
237
  }
238
+ /**
239
+ * `make:resource user`: a REST resource for a model. The model is reused when
240
+ * it exists, otherwise generated from the migration that creates its table;
241
+ * then its DTOs, a service with the CRUD operations, and a controller exposing
242
+ * them are written. Nothing is written if any of those files already exists
243
+ * (unless `force`), or if the model's columns cannot be found.
244
+ */
245
+ function makeResource(name, opts = {}) {
246
+ const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
247
+ const model = resolveResourceModel(projectRoot, name, { table: opts.table });
248
+ const m = model.name;
249
+ const files = {
250
+ service: path_1.default.join(targetDir(projectRoot, "service", m.dirs), `${m.fileBase}.service.ts`),
251
+ controller: path_1.default.join(targetDir(projectRoot, "controller", m.dirs), `${m.fileBase}.controller.ts`),
252
+ dto: path_1.default.join(targetDir(projectRoot, "dto", m.dirs), `${m.fileBase}.dto.ts`),
253
+ };
254
+ if (!opts.force) {
255
+ const taken = Object.values(files).filter((f) => fs_1.default.existsSync(f) && !(model.typeorm && f === files.dto));
256
+ if (taken.length > 0) {
257
+ throw new errors_1.CliError(`Already exists: ${taken.map((f) => relPath(projectRoot, f)).join(", ")}. Use -f or --force to overwrite.`);
258
+ }
259
+ }
260
+ const controllerClass = `${m.base}Controller`;
261
+ const route = resourceRoute(m.dirs, m.base);
262
+ const written = [];
263
+ writeModelIfNew(projectRoot, model);
264
+ if (model.create !== undefined)
265
+ written.push(model.file);
266
+ if (model.typeorm) {
267
+ log_1.log.info(" The model is a TypeORM entity: generating a repository service and an untyped controller (no DTOs).");
268
+ }
269
+ else {
270
+ written.push(write(files.dto, renderDtoFor(model), opts.force, "DTO", projectRoot));
271
+ }
272
+ written.push(write(files.service, renderResourceService(model, files.service, `${m.base}Service`), opts.force, "Service", projectRoot));
273
+ written.push(write(files.controller, renderResourceController(model, files.controller, controllerClass, route, files.service, files.dto), opts.force, "Controller", projectRoot));
274
+ warnMissing(projectRoot, model);
275
+ log_1.log.info(` Routes: GET|POST /${route}, GET|PUT|DELETE /${route}/:id`);
276
+ log_1.log.info(` Register it in your app: app.useControllers([..., ${controllerClass}])`);
277
+ return written;
278
+ }
143
279
  function makeConfig(name, opts = {}) {
144
280
  const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
145
281
  const n = (0, names_1.resolveName)(name, "Config");
@@ -164,15 +300,6 @@ function migrationTimestamp(date = new Date()) {
164
300
  return (`${date.getFullYear()}${p(date.getMonth() + 1)}${p(date.getDate())}` +
165
301
  `${p(date.getHours())}${p(date.getMinutes())}${p(date.getSeconds())}`);
166
302
  }
167
- /** The `id` column for the project's database driver. */
168
- function idColumn(pkg) {
169
- const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
170
- if (deps.pg || deps.postgres)
171
- return `.addColumn("id", "serial", (col) => col.primaryKey())`;
172
- if (deps.tedious)
173
- return `.addColumn("id", "integer", (col) => col.identity().primaryKey())`;
174
- return `.addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())`;
175
- }
176
303
  /**
177
304
  * Create `<migrations>/<timestamp>_<name>.ts`. `create_<table>_table` gives a
178
305
  * create-table migration, `add_x_to_<table>_table` (also from/in, and
@@ -189,7 +316,7 @@ function makeMigration(name, opts = {}) {
189
316
  const alterTable = opts.table ??
190
317
  (opts.create ? undefined : snake.match(/^(?:add|remove|drop|alter|change|update)_\w+_(?:to|from|in|on)_(\w+?)_table$/)?.[1]);
191
318
  const content = createTable
192
- ? (0, stubs_1.renderStub)("migrations/create-table.stub", { table: createTable, idColumn: idColumn(pkg) })
319
+ ? (0, stubs_1.renderStub)("migrations/create-table.stub", { table: createTable })
193
320
  : alterTable
194
321
  ? (0, stubs_1.renderStub)("migrations/alter-table.stub", { table: alterTable })
195
322
  : (0, stubs_1.renderStub)("migrations/migration.stub");
@@ -0,0 +1,29 @@
1
+ /**
2
+ * Reads table schemas out of migration files, without running them: the
3
+ * `up()` code of every migration is scanned, in file order, and its schema
4
+ * changes are replayed. Used by `make:model` to declare a model's columns.
5
+ *
6
+ * It understands Megh's schema builder (`defineMigration`, with
7
+ * `schema.create` / `schema.table` / `schema.drop`), and Kysely's
8
+ * `createTable` / `alterTable` / `dropTable` chains in older migrations.
9
+ * Anything it cannot read (raw SQL, computed names) is skipped.
10
+ */
11
+ export interface MigrationColumn {
12
+ name: string;
13
+ /** Data type as written, lower-cased, e.g. `"varchar(255)"`; `""` when not a literal. */
14
+ type: string;
15
+ notNull: boolean;
16
+ primaryKey: boolean;
17
+ /** The database fills it in: auto-increment, identity, serial or a default. */
18
+ generated: boolean;
19
+ /** Auto-increment / identity / serial (as opposed to a default value). */
20
+ autoIncrement: boolean;
21
+ }
22
+ export interface MigrationTable {
23
+ name: string;
24
+ columns: MigrationColumn[];
25
+ /** Migration that created the table (file name). */
26
+ createdIn: string;
27
+ }
28
+ /** Every table the migrations in `folder` leave behind, keyed by name. */
29
+ export declare function readMigrationSchema(folder: string): Map<string, MigrationTable>;