@neondatabase/neon-js 0.1.0-alpha.1

package/dist/cli/index.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import meow from "meow";
+import { PostgresMeta } from "@supabase/postgres-meta";
+import { getGeneratorMetadata } from "@supabase/postgres-meta/dist/lib/generators.js";
+import { apply } from "@supabase/postgres-meta/dist/server/templates/typescript.js";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+//#region src/cli/utils/parse-duration.ts
+function parseDuration(duration) {
+	const match = duration.match(/^(\d+)(s|m|h)?$/);
+	if (!match) throw new Error(`Invalid duration format: ${duration}. Use format like "30s", "1m", "90s"`);
+	const value = parseInt(match[1], 10);
+	const unit = match[2] || "s";
+	switch (unit) {
+		case "s": return value * 1e3;
+		case "m": return value * 60 * 1e3;
+		case "h": return value * 60 * 60 * 1e3;
+		default: throw new Error(`Unknown duration unit: ${unit}`);
+	}
+}
+
+//#endregion
+//#region src/cli/commands/generate-types.ts
+async function generateTypes(options) {
+	const { connectionString, schemas = ["public"], detectOneToOneRelationships = true } = options;
+	const pgMeta = new PostgresMeta({ connectionString });
+	try {
+		const { data: metadata } = await getGeneratorMetadata(pgMeta, { includedSchemas: schemas });
+		if (!metadata) throw new Error("No metadata found. Please check your database connection and schema.");
+		return await apply({
+			...metadata,
+			detectOneToOneRelationships
+		});
+	} finally {
+		await pgMeta.end();
+	}
+}
+
+//#endregion
+//#region src/cli/commands/gen-types.ts
+async function genTypes(flags) {
+	const dbUrl = flags.dbUrl?.trim();
+	if (!dbUrl) {
+		console.error("Error: --db-url is required");
+		console.error("Run \"neon-js gen-types --help\" for usage information");
+		process.exit(1);
+	}
+	const options = {
+		connectionString: dbUrl,
+		schemas: flags.schema,
+		detectOneToOneRelationships: !flags.postgrestV9Compat
+	};
+	if (flags.queryTimeout) try {
+		options.queryTimeout = parseDuration(flags.queryTimeout);
+	} catch (error) {
+		console.error(`Error: ${error instanceof Error ? error.message : error}`);
+		process.exit(1);
+	}
+	const outputPath = flags.output;
+	console.log("Generating types...");
+	console.log(`Database: ${options.connectionString.split("@")[1] || "connected"}`);
+	console.log(`Schemas: ${options.schemas?.join(", ") || "public"}`);
+	console.log(`Output: ${outputPath}`);
+	const types = await generateTypes(options);
+	const outputDir = dirname(outputPath);
+	if (outputDir !== ".") mkdirSync(outputDir, { recursive: true });
+	writeFileSync(outputPath, types);
+	console.log(`✅ Types generated successfully at ${outputPath}`);
+}
+
+//#endregion
+//#region src/cli/index.ts
+async function main() {
+	const cli = meow(`
+    Usage
+      $ neon-js gen-types --db-url <url> [options]
+
+    Commands
+      gen-types    Generate TypeScript types from your database schema
+
+    Required Options
+      --db-url <url>              Database connection string
+
+    Options
+      --output, -o <path>         Output file path (default: database.types.ts)
+      --schema, -s <name>         Schema to include (repeatable, default: public)
+      --postgrest-v9-compat       Disable one-to-one relationship detection
+      --query-timeout <duration>  Query timeout (default: 15s, format: 30s, 1m, 90s)
+
+    Examples
+      $ neon-js gen-types --db-url "postgresql://user:pass@host:5432/db"
+      $ neon-js gen-types --db-url "postgresql://..." --output src/types/db.ts
+      $ neon-js gen-types --db-url "postgresql://..." -s public -s auth
+      $ neon-js gen-types --db-url "postgresql://..." --postgrest-v9-compat
+      $ neon-js gen-types --db-url "postgresql://..." --query-timeout 30s
+  `, {
+		importMeta: import.meta,
+		description: "A TypeScript SDK for Neon services",
+		flags: {
+			dbUrl: {
+				type: "string",
+				isRequired: (flags, input) => {
+					if (flags.help || flags.version || input.length === 0) return false;
+					return true;
+				}
+			},
+			output: {
+				type: "string",
+				shortFlag: "o",
+				default: "database.types.ts"
+			},
+			schema: {
+				type: "string",
+				shortFlag: "s",
+				isMultiple: true,
+				default: ["public"]
+			},
+			postgrestV9Compat: {
+				type: "boolean",
+				default: false
+			},
+			queryTimeout: { type: "string" }
+		}
+	});
+	const command = cli.input[0];
+	if (!command) {
+		cli.showHelp(0);
+		return;
+	}
+	if (cli.flags.help) {
+		cli.showHelp(0);
+		return;
+	}
+	if (command === "gen-types") await genTypes(cli.flags);
+	else {
+		console.error(`Unknown command: ${command}`);
+		console.error("Run \"neon-js --help\" for usage information");
+		process.exit(1);
+	}
+}
+main();
+
+//#endregion
+export {  };

package/dist/index.d.ts

@@ -0,0 +1,147 @@
+import { AdminUserAttributes, AuthApiError, AuthChangeEvent, AuthClient as AuthClient$1, AuthError, AuthResponse, Provider as OAuthProvider, Session, SignInWithOAuthCredentials, SignInWithPasswordCredentials as SignInCredentials, SignUpWithPasswordCredentials as SignUpCredentials, Subscription, User, UserAttributes, UserResponse, VerifyOtpParams as VerifyOTPParams, isAuthError } from "@supabase/auth-js";
+import { StackClientApp, StackClientAppConstructorOptions, StackServerApp, StackServerAppConstructorOptions } from "@stackframe/js";
+import { PostgrestClient } from "@supabase/postgrest-js";
+import { StackClientInterface } from "@stackframe/stack-shared";
+import { InternalSession } from "@stackframe/stack-shared/dist/sessions";
+
+//#region src/auth/auth-interface.d.ts
+type _AuthClientSupabaseInstance = InstanceType<typeof AuthClient$1>;
+type AuthClient = { [K in keyof _AuthClientSupabaseInstance as _AuthClientSupabaseInstance[K] extends never ? never : K]: _AuthClientSupabaseInstance[K] };
+//#endregion
+//#region src/auth/adapters/stack-auth/stack-auth-types.d.ts
+interface StackAppInternals {
+  _getSession(overrideTokenStoreInit?: any): Promise<InternalSession>;
+  _getSessionFromTokenStore(tokenStore: any): InternalSession;
+  _getOrCreateTokenStore(cookieHelper: any, overrideTokenStoreInit?: any): any;
+  _createCookieHelper(): Promise<any>;
+  _interface: StackClientInterface;
+  redirectToAfterSignOut(): Promise<void>;
+}
+/**
+ * Stack Auth client
+ * This type extends StackServerApp or StackClientApp to include the _interface property
+ * This is a workaround to get the _interface property from the StackAuthAdapter
+ */
+type StackAuthClient = (StackServerApp | StackClientApp) & StackAppInternals;
+/**
+ * OnAuthStateChangeConfig type
+ * This type is used to configure the onAuthStateChange function
+ * It is based on the OnAuthStateChangeConfig type from Stack Auth (not exported)
+ */
+interface OnAuthStateChangeConfig {
+  enableTokenRefreshDetection?: boolean;
+  tokenRefreshCheckInterval?: number;
+}
+//#endregion
+//#region src/auth/adapters/stack-auth/stack-auth-adapter.d.ts
+/**
+ * Stack Auth adapter implementing the AuthClient interface
+ */
+declare class StackAuthAdapter<HasTokenStore extends boolean = boolean, ProjectId extends string = string> implements AuthClient {
+  stackAuth: StackAuthClient;
+  private stateChangeEmitters;
+  private broadcastChannel;
+  private tokenRefreshCheckInterval;
+  private config;
+  constructor(params: StackServerAppConstructorOptions<HasTokenStore, ProjectId>, config?: OnAuthStateChangeConfig);
+  admin: AuthClient['admin'];
+  mfa: AuthClient['mfa'];
+  initialize: AuthClient['initialize'];
+  signUp: AuthClient['signUp'];
+  signInAnonymously: AuthClient['signInAnonymously'];
+  signInWithPassword: AuthClient['signInWithPassword'];
+  signInWithOAuth: AuthClient['signInWithOAuth'];
+  signInWithOtp: AuthClient['signInWithOtp'];
+  signInWithIdToken: AuthClient['signInWithIdToken'];
+  signInWithSSO: AuthClient['signInWithSSO'];
+  signInWithWeb3: AuthClient['signInWithWeb3'];
+  signOut: AuthClient['signOut'];
+  verifyOtp: AuthClient['verifyOtp'];
+  /**
+   * Fetches fresh session data from Stack Auth API.
+   * Always makes a network request to get the latest user metadata.
+   * Used when we need fresh data (after setSession, refreshSession, etc.)
+   */
+  private _fetchFreshSession;
+  getSession: AuthClient['getSession'];
+  refreshSession: AuthClient['refreshSession'];
+  setSession: AuthClient['setSession'];
+  getUser: AuthClient['getUser'];
+  getClaims: AuthClient['getClaims'];
+  updateUser: AuthClient['updateUser'];
+  getUserIdentities: AuthClient['getUserIdentities'];
+  linkIdentity: AuthClient['linkIdentity'];
+  unlinkIdentity: AuthClient['unlinkIdentity'];
+  resetPasswordForEmail: AuthClient['resetPasswordForEmail'];
+  reauthenticate: AuthClient['reauthenticate'];
+  resend: AuthClient['resend'];
+  onAuthStateChange: AuthClient['onAuthStateChange'];
+  private _getSessionFromStackAuthInternals;
+  private _getCachedTokensFromStackAuthInternals;
+  private emitInitialSession;
+  private notifyAllSubscribers;
+  private initializeBroadcastChannel;
+  private closeBroadcastChannel;
+  private startTokenRefreshDetection;
+  private stopTokenRefreshDetection;
+  /**
+   * Exchange an OAuth authorization code for a session.
+   *
+   * Note: Stack Auth handles OAuth callbacks automatically via callOAuthCallback().
+   * This method delegates to Stack Auth's internal flow which:
+   * - Retrieves the code and state from the current URL
+   * - Retrieves the PKCE verifier from cookies (stored during signInWithOAuth)
+   * - Exchanges the code for access/refresh tokens
+   * - Creates and stores the user session
+   *
+   * @param authCode - The authorization code (Stack Auth reads this from URL automatically)
+   * @returns Session data or error
+   */
+  exchangeCodeForSession: AuthClient['exchangeCodeForSession'];
+  startAutoRefresh: AuthClient['startAutoRefresh'];
+  stopAutoRefresh: AuthClient['stopAutoRefresh'];
+}
+//#endregion
+//#region src/client/neon-client.d.ts
+type NeonClientConstructorOptions<SchemaName> = {
+  url: string;
+  options?: {
+    db?: {
+      schema?: Exclude<SchemaName, '__InternalSupabase'>;
+    };
+    global?: {
+      fetch: typeof fetch;
+      headers?: Record<string, string>;
+    };
+  };
+};
+type DefaultSchemaName<Database> = 'public' extends keyof Database ? 'public' : string & keyof Database;
+declare class NeonClient<Database = any, SchemaName extends string & keyof Database = DefaultSchemaName<Database>> extends PostgrestClient<Database, {
+  PostgrestVersion: '12';
+}, Exclude<SchemaName, '__InternalSupabase'>> {
+  auth?: AuthClient;
+  constructor({
+    url,
+    options
+  }: NeonClientConstructorOptions<SchemaName>);
+}
+//#endregion
+//#region src/client/client-factory.d.ts
+type StackAuthOptions<HasTokenStore extends boolean = boolean, ProjectId extends string = string> = StackClientAppConstructorOptions<HasTokenStore, ProjectId> | StackServerAppConstructorOptions<HasTokenStore, ProjectId>;
+type CreateClientOptions<SchemaName> = NeonClientConstructorOptions<SchemaName> & {
+  auth: StackAuthOptions;
+};
+/**
+ * Factory function to create NeonClient with seamless auth integration
+ *
+ * @param options - Configuration options
+ * @returns NeonClient instance with auth-aware fetch wrapper
+ * @throws AuthRequiredError when making requests without authentication
+ */
+declare function createClient<Database = any, SchemaName extends string & keyof Database = DefaultSchemaName<Database>>({
+  url,
+  auth: authOptions,
+  options
+}: CreateClientOptions<SchemaName>): NeonClient<Database, SchemaName>;
+//#endregion
+export { type AdminUserAttributes, AuthApiError, type AuthChangeEvent, type AuthClient, AuthError, type AuthResponse, type CreateClientOptions, NeonClient, type OAuthProvider, type Session, type SignInCredentials, type SignInWithOAuthCredentials, type SignUpCredentials, StackAuthAdapter, type Subscription, type User, type UserAttributes, type UserResponse, type VerifyOTPParams, createClient, isAuthError };