create-orchid-orm 0.0.1

package/dist/bin.js

@@ -0,0 +1,729 @@
+#!/usr/bin/env node
+'use strict';
+
+var prompts = require('prompts');
+var path = require('path');
+var fs = require('fs/promises');
+var https = require('https');
+
+async function readFileSafe(path) {
+  try {
+    return await fs.readFile(path, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+function makeFileTimeStamp(now) {
+  return [
+    now.getUTCFullYear(),
+    now.getUTCMonth() + 1,
+    now.getUTCDate(),
+    now.getUTCHours(),
+    now.getUTCMinutes(),
+    now.getUTCSeconds()
+  ].map((value) => value < 10 ? `0${value}` : value).join("");
+}
+function getLatestPackageVersion(name, kind) {
+  return new Promise((resolve, reject) => {
+    https.get(`https://registry.npmjs.org/${name}/latest`, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on(
+        "end",
+        () => resolve([name, { version: `^${JSON.parse(data).version}`, kind }])
+      );
+    }).on("error", reject);
+  });
+}
+function getPackageManagerName() {
+  const { npm_execpath } = process.env;
+  if (npm_execpath) {
+    const name = path.basename(npm_execpath);
+    if (/npm/.test(name)) {
+      return "npm";
+    }
+    if (/yarn/.test(name)) {
+      return "yarn";
+    }
+    if (/bun/.test(name)) {
+      return "bun";
+    }
+  }
+  return "pnpm";
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+async function getConfig(logger = console) {
+  let cancelled = false;
+  logger.log("Welcome to Orchid ORM installer!");
+  const isBun = getPackageManagerName() === "bun";
+  const response = await prompts(
+    [
+      {
+        type: "text",
+        name: "path",
+        message: "Where to install Orchid ORM?",
+        initial: process.cwd()
+      },
+      ...isBun ? [] : [
+        {
+          type: "select",
+          name: "runner",
+          message: "Choose a tool for executing TS files",
+          choices: [
+            {
+              title: "tsx",
+              value: "tsx"
+            },
+            {
+              title: "vite-node",
+              value: "vite-node"
+            },
+            {
+              title: "ts-node",
+              value: "ts-node"
+            }
+          ]
+        }
+      ],
+      {
+        type: "select",
+        name: "timestamp",
+        message: "Return timestamps as:",
+        choices: [
+          {
+            title: "string (as returned from db)",
+            value: "string"
+          },
+          {
+            title: "number (epoch)",
+            value: "number"
+          },
+          {
+            title: "Date object",
+            value: "date"
+          }
+        ]
+      },
+      {
+        type: "confirm",
+        name: "testDatabase",
+        message: "Add a separate database for tests?"
+      },
+      {
+        type: "confirm",
+        name: "addSchemaToZod",
+        message: "Add Zod for validations?"
+      },
+      {
+        type: "confirm",
+        name: "addTestFactory",
+        message: "Add record factories for writing tests?"
+      },
+      {
+        type: "confirm",
+        name: "demoTables",
+        message: "Add demo tables?"
+      }
+    ],
+    {
+      onCancel() {
+        cancelled = true;
+      }
+    }
+  );
+  if (isBun)
+    response.runner = "bun";
+  if (cancelled)
+    return;
+  const path$1 = path.resolve(response.path);
+  const tsConfigPath = path.join(path$1, "tsconfig.json");
+  const hasTsConfig = await readFileSafe(tsConfigPath);
+  const dbDirPath = path.join(path$1, "src", "db");
+  return __spreadProps(__spreadValues$1({}, response), {
+    hasTsConfig: !!hasTsConfig,
+    path: path.resolve(response.path),
+    dbDirPath,
+    projectName: path.basename(path$1),
+    esm: response.runner !== "ts-node"
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+async function setupPackageJSON(config) {
+  const pairs = await Promise.all([
+    getLatestPackageVersion("dotenv", "dependencies"),
+    getLatestPackageVersion("orchid-orm", "dependencies"),
+    getLatestPackageVersion("pqb", "dependencies"),
+    config.addSchemaToZod && getLatestPackageVersion("orchid-orm-schema-to-zod", "dependencies"),
+    getLatestPackageVersion("rake-db", "devDependencies"),
+    config.addTestFactory && getLatestPackageVersion("orchid-orm-test-factory", "devDependencies"),
+    getLatestPackageVersion("@types/node", "devDependencies"),
+    getLatestPackageVersion("typescript", "devDependencies"),
+    config.runner === "vite-node" && getLatestPackageVersion("vite", "devDependencies"),
+    config.runner !== "bun" && getLatestPackageVersion(config.runner, "devDependencies"),
+    config.runner === "vite-node" && getLatestPackageVersion(
+      "rollup-plugin-node-externals",
+      "devDependencies"
+    ),
+    config.runner === "tsx" && getLatestPackageVersion("esbuild", "devDependencies"),
+    config.runner === "tsx" && getLatestPackageVersion("rimraf", "devDependencies")
+  ]);
+  const deps = {};
+  const devDeps = {};
+  for (const item of pairs) {
+    if (!item)
+      continue;
+    const [key, { version, kind }] = item;
+    (kind === "dependencies" ? deps : devDeps)[key] = version;
+  }
+  const packageJsonPath = path.join(config.path, "package.json");
+  const content = await readFileSafe(packageJsonPath);
+  let json = content ? JSON.parse(content) : {
+    name: config.projectName
+  };
+  if (config.esm)
+    json = __spreadValues({ name: json.name, type: "module" }, json);
+  if (!json.scripts)
+    json.scripts = {};
+  let db;
+  let build;
+  let compiledDb;
+  if (config.runner === "vite-node") {
+    db = "vite-node src/db/dbScript.ts --";
+    build = "vite build --config vite.migrations.ts";
+    compiledDb = "node dist/db/dbScript.js";
+  } else if (config.runner === "tsx") {
+    db = "NODE_ENV=development tsx src/db/dbScript.ts";
+    build = "rimraf dist/db && node esbuild.migrations.js";
+    compiledDb = "NODE_ENV=production node dist/db/dbScript.js";
+  } else {
+    db = `${config.runner} src/db/dbScript.ts`;
+  }
+  json.scripts.db = db;
+  if (build) {
+    json.scripts["build:migrations"] = build;
+  }
+  if (compiledDb) {
+    json.scripts["db:compiled"] = compiledDb;
+  }
+  if (!json.dependencies)
+    json.dependencies = {};
+  for (const key in deps) {
+    json.dependencies[key] = deps[key];
+  }
+  if (!json.devDependencies)
+    json.devDependencies = {};
+  for (const key in devDeps) {
+    json.devDependencies[key] = devDeps[key];
+  }
+  await fs.writeFile(packageJsonPath, JSON.stringify(json, null, "  ") + "\n");
+}
+
+async function setupTSConfig(config) {
+  if (config.hasTsConfig)
+    return;
+  const module = config.runner === "ts-node" ? "commonjs" : "esnext";
+  const moduleResolution = config.runner === "ts-node" ? "" : `
+    "moduleResolution": "bundler",`;
+  const types = config.runner === "vite-node" ? `["vite/client"]` : void 0;
+  const tsConfigPath = path.join(config.path, "tsconfig.json");
+  await fs.writeFile(
+    tsConfigPath,
+    `{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "${module}",${moduleResolution}
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true${types ? `,
+    "types": ${types}` : ""}
+  }
+}
+`
+  );
+}
+
+async function setupEnv(config) {
+  const envPath = path.join(config.path, ".env");
+  let content = (await readFileSafe(envPath) || "").trim();
+  let changed = false;
+  const user = process.platform === "darwin" ? process.env.USER : "postgres";
+  if (!content.match(/^DATABASE_URL=/m)) {
+    content += `
+DATABASE_URL=postgres://${user}:@localhost:5432/dbname?ssl=false`;
+    changed = true;
+  }
+  if (config.testDatabase && !content.match(/^DATABASE_TEST_URL=/m)) {
+    content += `
+DATABASE_TEST_URL=postgres://${user}:@localhost:5432/dbname-test?ssl=false`;
+    changed = true;
+  }
+  if (changed) {
+    await fs.writeFile(envPath, `${content.trim()}
+`);
+  }
+}
+
+async function setupGitIgnore(config) {
+  const gitignorePath = path.join(config.path, ".gitignore");
+  let content = (await readFileSafe(gitignorePath) || "").trim();
+  let changed = false;
+  if (!content.match(/^node_modules\b/m)) {
+    content += `
+node_modules`;
+    changed = true;
+  }
+  if (!content.match(/^.env\b/m)) {
+    content += `
+.env.?*
+!.env.example`;
+    changed = true;
+  }
+  if (changed) {
+    await fs.writeFile(gitignorePath, `${content.trim()}
+`);
+  }
+}
+
+async function setupBaseTable(config) {
+  const filePath = path.join(config.dbDirPath, "baseTable.ts");
+  let content = `import { createBaseTable } from 'orchid-orm';${config.addSchemaToZod ? `
+import { zodSchemaProvider } from 'orchid-orm-schema-to-zod';` : ""}
+
+export const BaseTable = createBaseTable({
+  // Customize column types for all tables.
+  columnTypes: (t) => ({
+    ...t,${config.addSchemaToZod ? `
+    // Set min and max validations for all text columns,
+    // it is only checked when validating with Zod schemas derived from the table.
+    text: (min = 0, max = Infinity) => t.text(min, max),` : ""}`;
+  const { timestamp } = config;
+  if (timestamp && timestamp !== "string") {
+    content += `
+    // Parse timestamps to ${timestamp === "number" ? "number" : "Date object"}.
+    timestamp: <P extends number>(precision?: P) =>
+      t.timestamp<P>(precision).${timestamp === "date" ? "asDate" : "asNumber"}(),`;
+  }
+  content += `
+  }),${config.addSchemaToZod ? `
+  schemaProvider: zodSchemaProvider,` : ""}
+});
+`;
+  await fs.writeFile(filePath, content);
+}
+
+async function setupDemoTables(config) {
+  if (!config.demoTables)
+    return;
+  const tablesDir = path.join(config.dbDirPath, "tables");
+  await fs.mkdir(tablesDir, { recursive: true });
+  await fs.writeFile(
+    path.join(tablesDir, "post.table.ts"),
+    `import { Selectable, Updateable, Insertable, Queryable } from 'orchid-orm';
+import { BaseTable } from '../baseTable';
+import { CommentTable } from './comment.table';
+
+// Post type returned from database.
+export type Post = Selectable<PostTable>;
+// Post type for insertion.
+export type PostNew = Insertable<PostTable>;
+// Post type for updates.
+export type PostUpdate = Updateable<PostTable>;
+// Post type used by query methods such as \`where\`.
+export type PostForQuery = Queryable<PostTable>;
+
+export class PostTable extends BaseTable {
+  readonly table = 'post';
+  columns = this.setColumns((t) => ({
+    id: t.identity().primaryKey(),
+    title: t.text(3, 100).unique(),
+    text: t.text(20, 10000),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    comments: this.hasMany(() => CommentTable, {
+      primaryKey: 'id',
+      foreignKey: 'postId',
+    }),
+  };
+}
+`
+  );
+  await fs.writeFile(
+    path.join(tablesDir, "comment.table.ts"),
+    `import { Selectable, Updateable, Insertable, Queryable } from 'orchid-orm';
+import { BaseTable } from '../baseTable';
+import { PostTable } from './post.table';
+
+// Comment type returned from database.
+export type Comment = Selectable<CommentTable>;
+// Comment type for insertion.
+export type CommentNew = Insertable<CommentTable>;
+// Comment type for updates.
+export type CommentUpdate = Updateable<CommentTable>;
+// Comment type used by query methods such as \`where\`.
+export type CommentForQuery = Queryable<CommentTable>;
+
+export class CommentTable extends BaseTable {
+  readonly table = 'comment';
+  columns = this.setColumns((t) => ({
+    id: t.identity().primaryKey(),
+    postId: t
+      .integer()
+      .foreignKey(() => PostTable, 'id')
+      .index(),
+    text: t.text(5, 1000),
+    ...t.timestamps(),
+  }));
+
+  relations = {
+    post: this.belongsTo(() => PostTable, {
+      primaryKey: 'id',
+      foreignKey: 'postId',
+    }),
+  };
+}
+`
+  );
+}
+
+async function setupConfig(config) {
+  const configPath = path.join(config.dbDirPath, "config.ts");
+  let content = `import 'dotenv/config';
+
+const database = {
+  databaseURL: process.env.DATABASE_URL,
+};
+if (!database.databaseURL) throw new Error('DATABASE_URL is missing in .env');`;
+  if (config.testDatabase) {
+    content += `
+
+const testDatabase = {
+  databaseURL: process.env.DATABASE_TEST_URL,
+};
+
+const allDatabases = [database];
+
+if (testDatabase.databaseURL) {
+  allDatabases.push(testDatabase);
+}`;
+  }
+  content += `
+
+export const config = {`;
+  if (config.testDatabase) {
+    content += `
+  allDatabases,`;
+  }
+  if (config.testDatabase) {
+    content += `
+  database: process.env.NODE_ENV === 'test' ? testDatabase : database,`;
+  } else {
+    content += `
+  database,`;
+  }
+  content += `
+};
+`;
+  await fs.writeFile(configPath, content);
+}
+
+async function setupMainDb(config) {
+  let imports = "";
+  let tables = "";
+  if (config.demoTables) {
+    imports += `
+import { PostTable } from './tables/post.table';
+import { CommentTable } from './tables/comment.table';`;
+    tables += `
+  post: PostTable,
+  comment: CommentTable,`;
+  }
+  const dbPath = path.join(config.dbDirPath, "db.ts");
+  await fs.writeFile(
+    dbPath,
+    `import { orchidORM } from 'orchid-orm';
+import { config } from './config';${imports}
+
+export const db = orchidORM(config.database, {${tables}
+});
+`
+  );
+}
+
+async function setupMigrationScript(config) {
+  const filePath = path.join(config.dbDirPath, "dbScript.ts");
+  const migrations = config.runner === "vite-node" ? "migrations: import.meta.glob('./migrations/*.ts')" : "migrationsPath: './migrations'";
+  const useCodeUpdater = config.runner === "vite-node" ? "import.meta.env.DEV" : `process.env.NODE_ENV === 'development'`;
+  await fs.writeFile(
+    filePath,
+    `import { rakeDb } from 'rake-db';
+import { appCodeUpdater } from 'orchid-orm/codegen';
+import { config } from './config';
+import { BaseTable } from './baseTable';
+
+export const change = rakeDb(${config.testDatabase ? "config.allDatabases" : "config.database"}, {
+  baseTable: BaseTable,
+  ${migrations},
+  appCodeUpdater: appCodeUpdater({
+    tablePath: (tableName) => \`./tables/\${tableName}.table.ts\`,
+    ormPath: './db.ts',
+  }),
+  // set to false to disable code updater
+  useCodeUpdater: ${useCodeUpdater},
+  commands: {
+    async seed() {
+      const { seed } = await import('./seed');
+      await seed();
+    },
+  },
+  import: (path) => import(path),
+});
+`
+  );
+}
+
+async function createDemoMigrations(config) {
+  const migrationsPath = path.join(config.dbDirPath, "migrations");
+  await fs.mkdir(migrationsPath, { recursive: true });
+  if (!config.demoTables)
+    return;
+  const now = /* @__PURE__ */ new Date();
+  const postPath = path.join(
+    migrationsPath,
+    `${makeFileTimeStamp(now)}_createPost.ts`
+  );
+  await fs.writeFile(
+    postPath,
+    `import { change } from '../dbScript';
+
+change(async (db) => {
+  await db.createTable('post', (t) => ({
+    id: t.identity().primaryKey(),
+    title: t.text().unique(),
+    text: t.text(),
+    ...t.timestamps(),
+  }));
+});
+`
+  );
+  now.setTime(now.getTime() + 1e3);
+  const commentPath = path.join(
+    migrationsPath,
+    `${makeFileTimeStamp(now)}_createComment.ts`
+  );
+  await fs.writeFile(
+    commentPath,
+    `import { change } from '../dbScript';
+
+change(async (db) => {
+  await db.createTable('comment', (t) => ({
+    id: t.identity().primaryKey(),
+    postId: t.integer().foreignKey('post', 'id').index(),
+    text: t.text(),
+    ...t.timestamps(),
+  }));
+});
+`
+  );
+}
+
+async function createDemoSeed(config) {
+  const filePath = path.join(config.dbDirPath, "seed.ts");
+  let content;
+  if (config.demoTables) {
+    content = `await db.post.findBy({ title: 'Sample post' }).orCreate({
+    title: 'Post',
+    text: 'This is a text for a sample post. It contains words, spaces, and punctuation.',
+    comments: {
+      create: [
+        {
+          text: 'Nice post!',
+        },
+        {
+          text: \`Too long, didn't read\`,
+        },
+      ],
+    },
+  });`;
+  } else {
+    content = `// create records here`;
+  }
+  await fs.writeFile(
+    filePath,
+    `import { db } from './db';
+
+export const seed = async () => {
+  ${content}
+
+  await db.$close();
+};
+`
+  );
+}
+
+async function setupRunner(config) {
+  if (config.runner === "vite-node") {
+    await fs.writeFile(
+      path.join(config.path, "vite.migrations.ts"),
+      `import { resolve } from 'path'
+import { defineConfig, PluginOption } from 'vite'
+import { nodeExternals } from 'rollup-plugin-node-externals';
+
+export default defineConfig({
+  plugins: [
+    {
+      ...nodeExternals(),
+      name: 'node-externals',
+      enforce: 'pre',
+      apply: 'build',
+    } as PluginOption
+  ],
+  build: {
+    outDir: resolve(__dirname, 'dist', 'db'),
+    lib: {
+      entry: resolve(__dirname, 'src/db/dbScript.ts'),
+      formats: ['es'],
+      fileName: 'dbScript',
+    },
+    rollupOptions: {
+      external: ["pqb", "rake-db"],
+    },
+  },
+})
+`
+    );
+  } else if (config.runner === "tsx") {
+    await fs.writeFile(
+      path.join(config.path, "esbuild.migrations.js"),
+      `import { build } from "esbuild";
+
+await Promise.all([
+  build({
+    entryPoints: ["src/db/dbScript.ts"],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    outdir: "dist/db",
+    banner: {
+      js: \`
+        import __path from 'node:path';
+        import { fileURLToPath as __fileURLToPath } from 'node:url';
+        import { createRequire as __createRequire } from 'module';
+        const require = __createRequire(import.meta.url);
+        const __filename = __fileURLToPath(import.meta.url);
+        const __dirname = __path.dirname(__filename);
+      \`,
+    },
+  }),
+  build({
+    entryPoints: ["src/db/migrations/*.ts"],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    outdir: "dist/db/migrations",
+    external: ['../dbScript'],
+    plugins: [{
+      name: 'add-js-suffix',
+      setup(build) {
+        build.onResolve({ filter: /.*/ }, (args) => {
+          if (args.importer) {
+            return { path: args.path + '.js', external: true }
+          }
+        })
+      },
+    }],
+  }),
+]);
+`
+    );
+  }
+}
+
+async function init(config) {
+  await fs.mkdir(config.dbDirPath, { recursive: true });
+  for (const key in initSteps) {
+    await initSteps[key](config);
+  }
+}
+const initSteps = {
+  setupPackageJSON,
+  setupTSConfig,
+  setupEnv,
+  setupGitIgnore,
+  setupBaseTable,
+  setupDemoTables,
+  setupConfig,
+  setupMainDb,
+  setupMigrationScript,
+  createDemoMigrations,
+  createDemoSeed,
+  setupRunner
+};
+
+function greetAfterInstall(config, logger = console) {
+  const relativePath = path.relative(process.cwd(), config.path);
+  const manager = getPackageManagerName();
+  const run = manager === "npm" ? `npm run` : manager;
+  logger.log(`
+Thank you for trying Orchid ORM!
+  
+To finish setup,${relativePath ? ` cd to the project and` : ""} install dependencies:
+${relativePath ? `
+> cd ${relativePath}` : ""}
+> ${manager} i
+
+Enter the correct database credentials to the .env file,
+then create the database:
+
+> ${run} db create
+
+And run the migrations:
+
+> ${run} db migrate
+`);
+}
+
+getConfig().then(
+  (config) => config && init(config).then(() => greetAfterInstall(config))
+);
+//# sourceMappingURL=bin.js.map