@meghjs/cli 0.5.0 → 0.5.1
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.
- package/dist/commands/migrate.d.ts +12 -3
- package/dist/commands/migrate.js +33 -17
- package/dist/commands/new.d.ts +7 -2
- package/dist/commands/new.js +81 -10
- package/dist/generators/make.d.ts +20 -0
- package/dist/generators/make.js +171 -44
- package/dist/generators/migration-schema.d.ts +29 -0
- package/dist/generators/migration-schema.js +398 -0
- package/dist/generators/orm-model.d.ts +23 -0
- package/dist/generators/orm-model.js +158 -0
- package/dist/generators/resource.d.ts +32 -0
- package/dist/generators/resource.js +277 -0
- package/dist/program.js +19 -6
- package/package.json +5 -5
- package/stubs/controllers/model-controller.stub +34 -0
- package/stubs/dtos/resource-dto.stub +28 -0
- package/stubs/migrations/alter-table.stub +13 -7
- package/stubs/migrations/create-table.stub +13 -13
- package/stubs/migrations/migration.stub +9 -7
- package/stubs/models/orm-model-blank.stub +10 -0
- package/stubs/models/orm-model.stub +7 -0
- package/stubs/services/model-service.stub +42 -0
- package/stubs/models/basic-model.stub +0 -4
- package/stubs/services/rest-service.stub +0 -34
package/dist/generators/make.js
CHANGED
|
@@ -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
|
-
|
|
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
|
|
67
|
-
return (0, stubs_1.renderStub)(
|
|
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
|
-
*
|
|
74
|
-
*
|
|
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
|
|
77
|
-
const
|
|
78
|
-
const
|
|
79
|
-
const
|
|
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
|
-
|
|
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
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
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
|
-
|
|
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 =
|
|
212
|
+
const route = resourceRoute(n.dirs, n.base);
|
|
115
213
|
let content;
|
|
116
214
|
if (opts.model) {
|
|
117
|
-
const
|
|
118
|
-
const
|
|
119
|
-
const serviceFile = path_1.default.join(targetDir(projectRoot, "service",
|
|
120
|
-
|
|
121
|
-
|
|
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
|
-
|
|
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
|
|
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>;
|