pecunia-cli 0.3.9 → 0.4.0

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.
Files changed (4) hide show
  1. package/dist/api.mjs +1 -1
  2. package/dist/{generators-27dPVtx_.mjs → generators-EoVt1CPk.mjs} +163 -161
  3. package/dist/index.mjs +1 -1
  4. package/package.json +1 -1
package/dist/api.mjs CHANGED
@@ -1,3 +1,3 @@
1
- import { a as generateKyselySchema, n as generateSchema, o as generateDrizzleSchema, r as generatePrismaSchema, t as adapters } from "./generators-27dPVtx_.mjs";
1
+ import { a as generateKyselySchema, n as generateSchema, o as generateDrizzleSchema, r as generatePrismaSchema, t as adapters } from "./generators-EoVt1CPk.mjs";
2
2
 
3
3
  export { adapters, generateDrizzleSchema, generateKyselySchema, generatePrismaSchema, generateSchema };
package/dist/{generators-27dPVtx_.mjs → generators-EoVt1CPk.mjs} RENAMED
@@ -31,22 +31,69 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
31
31
  usePlural: adapter.options?.adapterConfig?.usePlural
32
32
  });
33
33
  const circularReferenceFields = new Set(["defaultPaymentMethodId", "defaultPriceId"]);
34
- const sortedTableKeys = Object.keys(tables).sort((a, b) => {
35
- const tableA = tables[a];
36
- const tableB = tables[b];
37
- const orderA = tableA.order ?? 0;
38
- const orderB = tableB.order ?? 0;
39
- if (orderA !== orderB) return orderA - orderB;
40
- if (Object.values(tableA.fields).some((field) => field.references?.model === b || field.references?.model === getModelName(b))) return 1;
41
- if (Object.values(tableB.fields).some((field) => field.references?.model === a || field.references?.model === getModelName(a))) return -1;
42
- return 0;
43
- });
34
+ /**
35
+ * Build a safe table order to avoid forward-reference runtime errors.
36
+ * We do a simple topological sort by references, while ignoring references for
37
+ * known circular reference fields.
38
+ *
39
+ * If there is still a cycle (due to schema), we fall back to stable ordering
40
+ * by `order` and name.
41
+ */
42
+ function getSafeTableOrder(tableKeys) {
43
+ const deps = /* @__PURE__ */ new Map();
44
+ for (const key of tableKeys) {
45
+ deps.set(key, /* @__PURE__ */ new Set());
46
+ const table = tables[key];
47
+ for (const [fieldKey, field] of Object.entries(table.fields)) {
48
+ if (circularReferenceFields.has(fieldKey)) continue;
49
+ if (!field.references?.model) continue;
50
+ const refModel = field.references.model;
51
+ if (tables[refModel]) {
52
+ deps.get(key).add(refModel);
53
+ continue;
54
+ }
55
+ const found = tableKeys.find((k) => getModelName(k) === refModel);
56
+ if (found) deps.get(key).add(found);
57
+ }
58
+ }
59
+ const orderByMeta = (a, b) => {
60
+ const oa = tables[a]?.order ?? 0;
61
+ const ob = tables[b]?.order ?? 0;
62
+ if (oa !== ob) return oa - ob;
63
+ return a.localeCompare(b);
64
+ };
65
+ const result = [];
66
+ const perm = /* @__PURE__ */ new Set();
67
+ const temp = /* @__PURE__ */ new Set();
68
+ let hasCycle = false;
69
+ const visit = (n) => {
70
+ if (perm.has(n)) return;
71
+ if (temp.has(n)) {
72
+ hasCycle = true;
73
+ return;
74
+ }
75
+ temp.add(n);
76
+ const children = Array.from(deps.get(n) ?? []).sort(orderByMeta);
77
+ for (const m of children) visit(m);
78
+ temp.delete(n);
79
+ perm.add(n);
80
+ result.push(n);
81
+ };
82
+ for (const k of tableKeys.sort(orderByMeta)) visit(k);
83
+ if (hasCycle) return tableKeys.sort(orderByMeta);
84
+ return result;
85
+ }
86
+ const sortedTableKeys = getSafeTableOrder(Object.keys(tables));
87
+ function getIdColumn() {
88
+ if (databaseType === "pg") return `uuid("id").default(sql\`gen_random_uuid()\`).primaryKey()`;
89
+ if (databaseType === "mysql") return `varchar("id", { length: 36 }).primaryKey()`;
90
+ return `text("id").primaryKey()`;
91
+ }
44
92
  for (const tableKey of sortedTableKeys) {
45
93
  const table = tables[tableKey];
46
94
  const modelName = getModelName(tableKey);
47
95
  const fields = table.fields;
48
96
  function getType(name, field) {
49
- if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
50
97
  name = convertToSnakeCase(name, adapter.options?.camelCase);
51
98
  if (field.references?.field === "id") {
52
99
  if (databaseType === "pg") return `uuid('${name}')`;
@@ -54,17 +101,19 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
54
101
  return `text('${name}')`;
55
102
  }
56
103
  const type = field.type;
57
- if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
58
- sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
59
- pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
60
- mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
61
- }[databaseType];
62
- else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
104
+ if (typeof type !== "string") {
105
+ if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
106
+ sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
107
+ pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
108
+ mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
109
+ }[databaseType];
110
+ throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
111
+ }
63
112
  const dbTypeMap = {
64
113
  string: {
65
114
  sqlite: `text('${name}')`,
66
115
  pg: `text('${name}')`,
67
- mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
116
+ mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable || field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
68
117
  },
69
118
  boolean: {
70
119
  sqlite: `integer('${name}', { mode: 'boolean' })`,
@@ -100,173 +149,124 @@ const generateDrizzleSchema = async ({ options, file, adapter }) => {
100
149
  if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
101
150
  return dbTypeMap[databaseType];
102
151
  }
103
- let id = "";
104
- if (databaseType === "pg") id = `uuid("id").default(sql\`gen_random_uuid()\`).primaryKey()`;
105
- else if (databaseType === "mysql") id = `varchar("id", { length: 36 }).primaryKey()`;
106
- else id = `text("id").primaryKey()`;
107
- let indexes = [];
108
- const assignIndexes = (indexes$1) => {
109
- if (!indexes$1.length) return "";
110
- let code$1 = [`, (table) => [`];
111
- for (const index of indexes$1) code$1.push(` ${index.type}("${index.name}").on(table.${index.on}),`);
112
- code$1.push(`]`);
113
- return code$1.join("\n");
152
+ const indexes = [];
153
+ const assignIndexes = (indexesToAssign) => {
154
+ if (!indexesToAssign.length) return "";
155
+ const lines = [`, (table) => [`];
156
+ for (const idx of indexesToAssign) lines.push(` ${idx.type}("${idx.name}").on(table.${idx.on}),`);
157
+ lines.push(`]`);
158
+ return lines.join("\n");
114
159
  };
115
- const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
116
- id: ${id},
117
- ${Object.keys(fields).filter((field) => field !== "id").map((field) => {
118
- const attr = fields[field];
119
- const fieldName = attr.fieldName || field;
160
+ const fieldLines = Object.keys(fields).filter((field) => field !== "id").map((fieldKey) => {
161
+ const attr = fields[fieldKey];
162
+ const fieldName = attr.fieldName || fieldKey;
120
163
  let type = getType(fieldName, attr);
121
- if (attr.index && !attr.unique) indexes.push({
122
- type: "index",
123
- name: `${modelName}_${fieldName}_idx`,
124
- on: fieldName
125
- });
126
164
  if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
127
165
  if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
128
166
  else type += `.defaultNow()`;
129
167
  } else if (typeof attr.defaultValue === "string") type += `.default("${attr.defaultValue}")`;
130
168
  else type += `.default(${attr.defaultValue})`;
131
- if (attr.onUpdate && attr.type === "date") {
132
- if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
133
- }
134
- const isCircularReference = circularReferenceFields.has(field);
135
- const shouldAddReference = attr.references && !isCircularReference;
136
- if (isCircularReference && attr.index) indexes.push({
169
+ if (attr.onUpdate && attr.type === "date" && typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
170
+ if (attr.index && !attr.unique) indexes.push({
137
171
  type: "index",
138
172
  name: `${modelName}_${fieldName}_idx`,
139
173
  on: fieldName
140
174
  });
141
- return `${fieldName}: ${type}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${shouldAddReference ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
175
+ const isCircularReference = circularReferenceFields.has(fieldKey);
176
+ const referenceCode = !!attr.references && !isCircularReference ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
142
177
  model: attr.references.model,
143
178
  field: attr.references.field
144
- })}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
145
- }).join(",\n ")}
179
+ })}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : "";
180
+ return `${fieldName}: ${type}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${referenceCode}`;
181
+ });
182
+ const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
183
+ id: ${getIdColumn()},
184
+ ${fieldLines.join(",\n ")}
146
185
  }${assignIndexes(indexes)});`;
147
186
  code += `\n${schema}\n`;
148
187
  }
149
188
  let relationsString = "";
189
+ const normalizeManyKey = (key) => {
190
+ if (!adapter.options?.adapterConfig?.usePlural && !key.endsWith("s")) return `${key}s`;
191
+ return key;
192
+ };
150
193
  for (const tableKey of sortedTableKeys) {
151
194
  const table = tables[tableKey];
152
195
  const modelName = getModelName(tableKey);
153
196
  const oneRelations = [];
154
197
  const manyRelations = [];
155
- const manyRelationsSet = /* @__PURE__ */ new Set();
156
- const foreignFields = Object.entries(table.fields).filter(([fieldName, field]) => field.references || circularReferenceFields.has(fieldName) && field.type === "string");
157
- for (const [fieldName, field] of foreignFields) {
158
- let referencedModel;
159
- let referenceField = "id";
160
- if (field.references) {
161
- referencedModel = field.references.model;
162
- referenceField = field.references.field || "id";
163
- } else if (circularReferenceFields.has(fieldName)) if (fieldName === "defaultPaymentMethodId") referencedModel = "payment_method";
164
- else if (fieldName === "defaultPriceId") referencedModel = "prices";
165
- else continue;
166
- else continue;
167
- const relationKey = getModelName(referencedModel);
168
- let relationName;
169
- if (circularReferenceFields.has(fieldName)) relationName = fieldName.replace(/Id$/, "");
170
- else relationName = relationKey;
171
- const fieldRef = `${getModelName(tableKey)}.${getFieldName({
172
- model: tableKey,
173
- field: fieldName
174
- })}`;
175
- const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
176
- model: referencedModel,
177
- field: referenceField
178
- })}`;
198
+ const manyKeys = /* @__PURE__ */ new Set();
199
+ for (const [fieldKey, field] of Object.entries(table.fields)) {
200
+ if (!field.references) continue;
201
+ const referencedModel = field.references.model;
202
+ const referencedField = field.references.field || "id";
203
+ const key = getModelName(referencedModel);
179
204
  oneRelations.push({
180
- key: relationName,
205
+ key,
181
206
  model: getModelName(referencedModel),
182
207
  type: "one",
183
208
  reference: {
184
- field: fieldRef,
185
- references: referenceRef,
186
- fieldName
209
+ field: `${getModelName(tableKey)}.${getFieldName({
210
+ model: tableKey,
211
+ field: fieldKey
212
+ })}`,
213
+ references: `${getModelName(referencedModel)}.${getFieldName({
214
+ model: referencedModel,
215
+ field: referencedField
216
+ })}`
187
217
  }
188
218
  });
189
219
  }
190
- const otherModels = sortedTableKeys.filter((modelName$1) => modelName$1 !== tableKey).map((modelName$1) => [modelName$1, tables[modelName$1]]);
191
- const modelRelationsMap = /* @__PURE__ */ new Map();
192
- for (const [modelName$1, otherTable] of otherModels) {
193
- const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
194
- if (foreignKeysPointingHere.length === 0) continue;
195
- const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
196
- const hasMany$1 = foreignKeysPointingHere.some(([_, field]) => !field.unique);
197
- modelRelationsMap.set(modelName$1, {
198
- modelName: modelName$1,
199
- hasUnique,
200
- hasMany: hasMany$1
220
+ for (const circularField of circularReferenceFields) {
221
+ if (!table.fields[circularField]) continue;
222
+ let referencedModel = null;
223
+ if (circularField === "defaultPaymentMethodId") referencedModel = "payment_method";
224
+ if (circularField === "defaultPriceId") referencedModel = "prices";
225
+ if (!referencedModel) continue;
226
+ const relationKey = circularField.replace(/Id$/, "");
227
+ oneRelations.push({
228
+ key: relationKey,
229
+ model: getModelName(referencedModel),
230
+ type: "one",
231
+ reference: {
232
+ field: `${getModelName(tableKey)}.${getFieldName({
233
+ model: tableKey,
234
+ field: circularField
235
+ })}`,
236
+ references: `${getModelName(referencedModel)}.${getFieldName({
237
+ model: referencedModel,
238
+ field: "id"
239
+ })}`
240
+ }
201
241
  });
202
242
  }
203
- for (const { modelName: modelName$1, hasMany: hasMany$1 } of modelRelationsMap.values()) {
204
- const relationType = hasMany$1 ? "many" : "one";
205
- let relationKey = getModelName(modelName$1);
206
- if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") {
207
- if (!relationKey.endsWith("s")) relationKey = `${relationKey}s`;
208
- }
209
- const pluralFixes = {
210
- "productss": "products",
211
- "pricess": "prices",
212
- "webhook_deliverys": "webhookDeliveries",
213
- "webhookDeliverys": "webhookDeliveries"
214
- };
215
- if (pluralFixes[relationKey]) relationKey = pluralFixes[relationKey];
216
- if (!manyRelationsSet.has(relationKey)) {
217
- manyRelationsSet.add(relationKey);
218
- manyRelations.push({
219
- key: relationKey,
220
- model: getModelName(modelName$1),
221
- type: relationType
222
- });
223
- }
224
- }
225
- const relationsByModel = /* @__PURE__ */ new Map();
226
- for (const relation of oneRelations) if (relation.reference) {
227
- const modelKey = relation.key;
228
- if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
229
- relationsByModel.get(modelKey).push(relation);
230
- }
231
- const duplicateRelations = [];
232
- const singleRelations = [];
233
- for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
234
- else singleRelations.push(relations[0]);
235
- for (const relation of duplicateRelations) if (relation.reference) {
236
- const fieldName = relation.reference.fieldName;
237
- const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
238
- ${relation.key}: one(${relation.model}, {
239
- fields: [${relation.reference.field}],
240
- references: [${relation.reference.references}],
241
- })
242
- }))`;
243
- relationsString += `\n${tableRelation}\n`;
244
- }
245
- const hasOne = singleRelations.length > 0;
246
- const hasMany = manyRelations.length > 0;
247
- if (hasOne && hasMany) {
248
- const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
249
- ${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
250
- fields: [${relation.reference.field}],
251
- references: [${relation.reference.references}],
252
- })` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
253
- ${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
254
- }))`;
255
- relationsString += `\n${tableRelation}\n`;
256
- } else if (hasOne) {
257
- const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
258
- ${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
259
- fields: [${relation.reference.field}],
260
- references: [${relation.reference.references}],
261
- })` : "").filter((x) => x !== "").join(",\n ")}
262
- }))`;
263
- relationsString += `\n${tableRelation}\n`;
264
- } else if (hasMany) {
265
- const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
266
- ${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
267
- }))`;
268
- relationsString += `\n${tableRelation}\n`;
243
+ for (const otherKey of sortedTableKeys) {
244
+ if (otherKey === tableKey) continue;
245
+ const otherTable = tables[otherKey];
246
+ if (!Object.entries(otherTable.fields).filter(([, f]) => f.references?.model === tableKey).length) continue;
247
+ let key = normalizeManyKey(getModelName(otherKey));
248
+ if (manyKeys.has(key)) continue;
249
+ manyKeys.add(key);
250
+ manyRelations.push({
251
+ key,
252
+ model: getModelName(otherKey),
253
+ type: "many"
254
+ });
269
255
  }
256
+ const oneLines = oneRelations.map((r) => {
257
+ if (!r.reference) return "";
258
+ return ` ${r.key}: one(${r.model}, {
259
+ fields: [${r.reference.field}],
260
+ references: [${r.reference.references}],
261
+ })`;
262
+ }).filter(Boolean);
263
+ const manyLines = manyRelations.map((r) => ` ${r.key}: many(${r.model})`);
264
+ if (!oneLines.length && !manyLines.length) continue;
265
+ const args = oneLines.length && manyLines.length ? "({ one, many })" : oneLines.length ? "({ one })" : "({ many })";
266
+ const body = [...oneLines, ...manyLines].join(",\n");
267
+ relationsString += `\nexport const ${modelName}Relations = relations(${getModelName(table.modelName)}, ${args} => ({
268
+ ${body}
269
+ }));\n`;
270
270
  }
271
271
  code += `\n${relationsString}`;
272
272
  return {
@@ -288,27 +288,29 @@ function generateImport({ databaseType, tables }) {
288
288
  if (hasJson && hasBigint) break;
289
289
  }
290
290
  coreImports.push(`${databaseType}Table`);
291
- coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
292
- coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
293
- coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
291
+ if (databaseType === "mysql") coreImports.push("varchar, text");
292
+ else coreImports.push("text");
293
+ if (databaseType === "pg") coreImports.push("uuid");
294
+ if (databaseType === "sqlite") coreImports.push("integer");
295
+ coreImports.push(hasBigint && databaseType !== "sqlite" ? "bigint" : "");
296
+ if (databaseType !== "sqlite") coreImports.push("timestamp, boolean");
294
297
  if (databaseType === "mysql") {
295
298
  if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("int");
296
299
  if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
297
300
  } else if (databaseType === "pg") {
298
301
  rootImports.push("sql");
299
- coreImports.push("uuid");
300
302
  if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("integer");
301
- } else coreImports.push("integer");
303
+ }
302
304
  if (hasJson) {
303
305
  if (databaseType === "pg") coreImports.push("jsonb");
304
306
  if (databaseType === "mysql") coreImports.push("json");
305
307
  }
306
308
  if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
307
309
  const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
308
- const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
310
+ const hasUniqueOnColumn = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique));
309
311
  if (hasIndexes) coreImports.push("index");
310
- if (hasUniqueIndexes) coreImports.push("uniqueIndex");
311
- return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
312
+ if (hasUniqueOnColumn) {}
313
+ return `${rootImports.length ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter(Boolean).join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
312
314
  }
313
315
 
314
316
  //#endregion
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { i as getPackageInfo, n as generateSchema } from "./generators-27dPVtx_.mjs";
2
+ import { i as getPackageInfo, n as generateSchema } from "./generators-EoVt1CPk.mjs";
3
3
  import { Command } from "commander";
4
4
  import fs, { existsSync, readFileSync } from "node:fs";
5
5
  import fs$1 from "node:fs/promises";
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "pecunia-cli",
3
- "version": "0.3.9",
3
+ "version": "0.4.0",
4
4
  "type": "module",
5
5
  "module": "dist/index.mjs",
6
6
  "main": "./dist/index.mjs",