baasix 0.1.0

package/src/utils/api-client.ts

@@ -0,0 +1,121 @@
+import axios, { AxiosInstance } from "axios";
+import { BaasixConfig } from "./get-config.js";
+
+let client: AxiosInstance | null = null;
+let authToken: string | null = null;
+
+export async function createApiClient(config: BaasixConfig): Promise<AxiosInstance> {
+  if (client) {
+    return client;
+  }
+
+  client = axios.create({
+    baseURL: config.url,
+    timeout: 30000,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  // Authenticate if credentials provided
+  if (config.token) {
+    authToken = config.token;
+    client.defaults.headers.common["Authorization"] = `Bearer ${authToken}`;
+  } else if (config.email && config.password) {
+    try {
+      const response = await client.post("/auth/login", {
+        email: config.email,
+        password: config.password,
+      });
+      authToken = response.data.token;
+      client.defaults.headers.common["Authorization"] = `Bearer ${authToken}`;
+    } catch (error) {
+      throw new Error(`Failed to authenticate: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+
+  return client;
+}
+
+export function getAuthToken(): string | null {
+  return authToken;
+}
+
+export interface SchemaInfo {
+  collectionName: string;
+  schema: {
+    name: string;
+    timestamps?: boolean;
+    paranoid?: boolean;
+    fields: Record<string, FieldDefinition>;
+  };
+}
+
+export interface FieldDefinition {
+  type?: string;
+  primaryKey?: boolean;
+  allowNull?: boolean;
+  unique?: boolean;
+  defaultValue?: unknown;
+  values?: Record<string, unknown> | string[]; // Can be object with config or array for enums
+  validate?: {
+    min?: number;
+    max?: number;
+    len?: [number, number];
+    isEmail?: boolean;
+    isUrl?: boolean;
+    isIP?: boolean;
+    isUUID?: number;
+    regex?: string;
+    [key: string]: unknown;
+  };
+  // Relation fields
+  relType?: "BelongsTo" | "HasOne" | "HasMany" | "BelongsToMany";
+  target?: string;
+  foreignKey?: string;
+  as?: string;
+  description?: string;
+  SystemGenerated?: boolean | string;
+}
+
+export async function fetchSchemas(config: BaasixConfig): Promise<SchemaInfo[]> {
+  const client = await createApiClient(config);
+  const response = await client.get("/schemas", {
+    params: { limit: -1 },
+  });
+  return response.data.data || [];
+}
+
+export interface MigrationInfo {
+  id: string;
+  version: string;
+  name: string;
+  status: string;
+  type: string;
+  executedAt?: string;
+  batch?: number;
+}
+
+export async function fetchMigrations(config: BaasixConfig): Promise<MigrationInfo[]> {
+  const client = await createApiClient(config);
+  const response = await client.get("/migrations");
+  return response.data.data || [];
+}
+
+export async function runMigrations(config: BaasixConfig, options?: { 
+  dryRun?: boolean;
+  step?: number;
+}): Promise<{ success: boolean; message: string; migrations?: MigrationInfo[] }> {
+  const client = await createApiClient(config);
+  const response = await client.post("/migrations/run", options || {});
+  return response.data;
+}
+
+export async function rollbackMigrations(config: BaasixConfig, options?: {
+  step?: number;
+  batch?: number;
+}): Promise<{ success: boolean; message: string }> {
+  const client = await createApiClient(config);
+  const response = await client.post("/migrations/rollback", options || {});
+  return response.data;
+}

package/src/utils/get-config.ts

@@ -0,0 +1,69 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parse } from "dotenv";
+
+export interface BaasixConfig {
+  url: string;
+  email?: string;
+  password?: string;
+  token?: string;
+}
+
+/**
+ * Load Baasix configuration from .env file or environment variables
+ */
+export async function getConfig(cwd: string): Promise<BaasixConfig | null> {
+  // Check for .env file
+  const envPath = path.join(cwd, ".env");
+  let envVars: Record<string, string> = {};
+
+  if (existsSync(envPath)) {
+    const envContent = await fs.readFile(envPath, "utf-8");
+    envVars = parse(envContent);
+  }
+
+  // Merge with process.env (process.env takes precedence)
+  const mergedEnv = { ...envVars, ...process.env };
+
+  const url = mergedEnv.BAASIX_URL || mergedEnv.API_URL || "http://localhost:8056";
+  const email = mergedEnv.BAASIX_EMAIL || mergedEnv.ADMIN_EMAIL;
+  const password = mergedEnv.BAASIX_PASSWORD || mergedEnv.ADMIN_PASSWORD;
+  const token = mergedEnv.BAASIX_TOKEN || mergedEnv.BAASIX_AUTH_TOKEN;
+
+  if (!url) {
+    return null;
+  }
+
+  return {
+    url,
+    email,
+    password,
+    token,
+  };
+}
+
+/**
+ * Load configuration from baasix.config.js or baasix.config.ts if exists
+ */
+export async function loadConfigFile(cwd: string): Promise<Record<string, unknown> | null> {
+  const possiblePaths = [
+    "baasix.config.js",
+    "baasix.config.mjs",
+    "baasix.config.ts",
+  ];
+
+  for (const configPath of possiblePaths) {
+    const fullPath = path.join(cwd, configPath);
+    if (existsSync(fullPath)) {
+      try {
+        const config = await import(fullPath);
+        return config.default || config;
+      } catch {
+        // Ignore import errors
+      }
+    }
+  }
+
+  return null;
+}

package/src/utils/get-package-info.ts

@@ -0,0 +1,12 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export async function getPackageInfo(): Promise<Record<string, unknown>> {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+
+  const packageJsonPath = path.resolve(__dirname, "../../package.json");
+  const content = await fs.readFile(packageJsonPath, "utf-8");
+  return JSON.parse(content);
+}

package/src/utils/package-manager.ts

@@ -0,0 +1,62 @@
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+export type PackageManager = "npm" | "pnpm" | "bun" | "yarn";
+
+export function detectPackageManager(cwd: string): PackageManager {
+  if (existsSync(path.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+
+export function installDependencies({
+  dependencies,
+  packageManager,
+  cwd,
+  dev = false,
+}: {
+  dependencies: string[];
+  packageManager: PackageManager;
+  cwd: string;
+  dev?: boolean;
+}): Promise<boolean> {
+  let installCommand: string;
+  const devFlag = dev ? (packageManager === "npm" ? " --save-dev" : " -D") : "";
+
+  switch (packageManager) {
+    case "npm":
+      installCommand = `npm install${devFlag}`;
+      break;
+    case "pnpm":
+      installCommand = `pnpm add${devFlag}`;
+      break;
+    case "bun":
+      installCommand = `bun add${devFlag}`;
+      break;
+    case "yarn":
+      installCommand = `yarn add${devFlag}`;
+      break;
+    default:
+      throw new Error("Invalid package manager");
+  }
+
+  const command = `${installCommand} ${dependencies.join(" ")}`;
+
+  return new Promise((resolve, reject) => {
+    exec(command, { cwd }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+        return;
+      }
+      resolve(true);
+    });
+  });
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  outExtension() {
+    return {
+      js: ".mjs",
+    };
+  },
+  dts: true,
+  clean: true,
+  banner: {
+    js: "#!/usr/bin/env node",
+  },
+});