@wasp.sh/wasp-cli-darwin-x64-unknown 0.25.0 → 0.26.0

package/data/Generator/templates/sdk/wasp/server/auth/user.ts

@@ -1,154 +0,0 @@
-{{={= =}=}}
-import {
-  type {= userEntityName =},
-  type {= authEntityName =},
-  type {= authIdentityEntityName =},
-} from '../../entities/index.js'
-import {
-  type PossibleProviderData,
-  getProviderData,
-} from '../../auth/utils.js'
-import { type ProviderName } from '../_types/index.js'
-import { Expand } from '../../universal/types.js'
-
-// PUBLIC API
-export type AuthUser = AuthUserData & {
-  getFirstProviderUserId: () => string | null,
-}
-
-// PRIVATE API
-/*
- * Ideally, we'd do something like this:
- * ```
- * export type AuthUserData = ReturnType<typeof createAuthUserData>
- * ```
- * to get the benefits of the createAuthUser and the AuthUserData type being in sync.
- * 
- * But since we are not using strict mode, the inferred return type of createAuthUser
- * is not correct. So we have to define the AuthUserData type manually.
- * 
- * TODO: Change this once/if we switch to strict mode. https://github.com/wasp-lang/wasp/issues/1938
- */
-export type AuthUserData = Omit<CompleteUserEntityWithAuth, '{= authFieldOnUserEntityName =}'> & {
-  identities: {
-    {=# enabledProviders.isEmailAuthEnabled =}
-    email: Expand<UserFacingProviderData<'email'>> | null
-    {=/ enabledProviders.isEmailAuthEnabled =}
-    {=# enabledProviders.isUsernameAndPasswordAuthEnabled =}
-    username: Expand<UserFacingProviderData<'username'>> | null
-    {=/ enabledProviders.isUsernameAndPasswordAuthEnabled =}
-    {=# enabledProviders.isSlackAuthEnabled =}
-    slack: Expand<UserFacingProviderData<'slack'>> | null
-    {=/ enabledProviders.isSlackAuthEnabled =}
-    {=# enabledProviders.isDiscordAuthEnabled =}
-    discord: Expand<UserFacingProviderData<'discord'>> | null
-    {=/ enabledProviders.isDiscordAuthEnabled =}
-    {=# enabledProviders.isGoogleAuthEnabled =}
-    google: Expand<UserFacingProviderData<'google'>> | null
-    {=/ enabledProviders.isGoogleAuthEnabled =}
-    {=# enabledProviders.isKeycloakAuthEnabled =}
-    keycloak: Expand<UserFacingProviderData<'keycloak'>> | null
-    {=/ enabledProviders.isKeycloakAuthEnabled =}
-    {=# enabledProviders.isGitHubAuthEnabled =}
-    github: Expand<UserFacingProviderData<'github'>> | null
-    {=/ enabledProviders.isGitHubAuthEnabled =}
-    {=# enabledProviders.isMicrosoftAuthEnabled =}
-    microsoft: Expand<UserFacingProviderData<'microsoft'>> | null
-    {=/ enabledProviders.isMicrosoftAuthEnabled =}
-  },
-}
-
-type UserFacingProviderData<PN extends ProviderName> = {
-  id: string
-} & Omit<PossibleProviderData[PN], 'hashedPassword'>
-
-// PRIVATE API
-export type CompleteUserEntityWithAuth =
-  MakeUserEntityWithAuth<CompleteAuthEntityWithIdentities>
-
-// PRIVATE API
-export type CompleteAuthEntityWithIdentities =
-  MakeAuthEntityWithIdentities<{= authIdentityEntityName =}>
-
-// PRIVATE API
-/**
- * User entity with all of the auth related data that's needed for the user facing
- * helper functions like `getUsername` and `getEmail`.
- */
-export type UserEntityWithAuth = MakeUserEntityWithAuth<
-  MakeAuthEntityWithIdentities<
-    // It's constructed like the Complete* types, but only with the fields needed
-    // for the user facing functions.
-    Pick<{= authIdentityEntityName =}, 'providerName' | 'providerUserId'>
-  >
->
-
-type MakeUserEntityWithAuth<AuthType> = {= userEntityName =} & {
-  {= authFieldOnUserEntityName =}: AuthType | null
-}
-
-type MakeAuthEntityWithIdentities<IdentityType> = {= authEntityName =} & {
-  {= identitiesFieldOnAuthEntityName =}: IdentityType[]
-}
-
-// PRIVATE API
-export function createAuthUserData(user: CompleteUserEntityWithAuth): AuthUserData {
-  const { {= authFieldOnUserEntityName =}, ...rest } = user
-  if (!{= authFieldOnUserEntityName =}) {
-    throw new Error(`🐝 Error: trying to create a user without auth data.
-This should never happen, but it did which means there is a bug in the code.`)
-  }
-  const identities = {
-    {=# enabledProviders.isEmailAuthEnabled =}
-    email: getProviderInfo<'email'>({= authFieldOnUserEntityName =}, 'email'),
-    {=/ enabledProviders.isEmailAuthEnabled =}
-    {=# enabledProviders.isUsernameAndPasswordAuthEnabled =}
-    username: getProviderInfo<'username'>({= authFieldOnUserEntityName =}, 'username'),
-    {=/ enabledProviders.isUsernameAndPasswordAuthEnabled =}
-    {=# enabledProviders.isSlackAuthEnabled =}
-    slack: getProviderInfo<'slack'>({= authFieldOnUserEntityName =}, 'slack'),
-    {=/ enabledProviders.isSlackAuthEnabled =}
-    {=# enabledProviders.isDiscordAuthEnabled =}
-    discord: getProviderInfo<'discord'>({= authFieldOnUserEntityName =}, 'discord'),
-    {=/ enabledProviders.isDiscordAuthEnabled =}
-    {=# enabledProviders.isGoogleAuthEnabled =}
-    google: getProviderInfo<'google'>({= authFieldOnUserEntityName =}, 'google'),
-    {=/ enabledProviders.isGoogleAuthEnabled =}
-    {=# enabledProviders.isKeycloakAuthEnabled =}
-    keycloak: getProviderInfo<'keycloak'>({= authFieldOnUserEntityName =}, 'keycloak'),
-    {=/ enabledProviders.isKeycloakAuthEnabled =}
-    {=# enabledProviders.isGitHubAuthEnabled =}
-    github: getProviderInfo<'github'>({= authFieldOnUserEntityName =}, 'github'),
-    {=/ enabledProviders.isGitHubAuthEnabled =}
-    {=# enabledProviders.isMicrosoftAuthEnabled =}
-    microsoft: getProviderInfo<'microsoft'>({= authFieldOnUserEntityName =}, 'microsoft'),
-    {=/ enabledProviders.isMicrosoftAuthEnabled =}
-  }
-  return {
-    ...rest,
-    identities,
-  }
-}
-
-function getProviderInfo<PN extends ProviderName>(
-  auth: CompleteAuthEntityWithIdentities,
-  providerName: PN
-):
-  | UserFacingProviderData<PN>
-  | null {
-  const identity = getIdentity(auth, providerName)
-  if (!identity) {
-    return null
-  }
-  return {
-    ...getProviderData<PN>(identity.providerData),
-    id: identity.providerUserId,
-  }
-}
-
-function getIdentity(
-  auth: CompleteAuthEntityWithIdentities,
-  providerName: ProviderName
-): {= authIdentityEntityName =} | null {
-  return auth.{= identitiesFieldOnAuthEntityName =}.find((i) => i.providerName === providerName) ?? null
-}

package/data/Generator/templates/sdk/wasp/server/auth/username.ts

@@ -1 +0,0 @@
-export { ensureValidUsername } from '../../auth/validation.js'

package/data/Generator/templates/sdk/wasp/server/jobs/core/job.ts

@@ -1,28 +0,0 @@
-/**
- * This is a definition of a job (think draft or invocable computation), not the running instance itself.
- * This can be submitted one or more times to be executed by some job executor via the same instance.
- * Once submitted, you get a SubmittedJob to track it later.
- */
-export class Job {
-  public readonly jobName: string
-  public readonly executorName: string | symbol
-
-  constructor(jobName: string, executorName: string | symbol) {
-    this.jobName = jobName
-    this.executorName = executorName
-  }
-}
-
-/**
- * This is the result of submitting a Job to some executor.
- * It can be used by callers to track things, or call executor-specific subclass functionality.
- */
-export class SubmittedJob {
-  public readonly job: Job
-  public readonly jobId: string
-
-  constructor(job: Job, jobId: string) {
-    this.job = job
-    this.jobId = jobId
-  }
-}

package/data/Generator/templates/sdk/wasp/server/middleware/globalMiddleware.ts

@@ -1,8 +0,0 @@
-import { type RequestHandler } from 'express'
-
-// PUBLIC API
-export type MiddlewareConfigFn = (middlewareConfig: MiddlewareConfig) => MiddlewareConfig
-
-// PRIVATE API
-export type MiddlewareConfig = Map<string, RequestHandler>
-

package/data/Generator/templates/sdk/wasp/universal/ansiColors.ts

@@ -1,58 +0,0 @@
-// PRIVATE API (SDK, client)
-/**
- * Wraps each line of text with ANSI color codes.
- * Only works in Node.js (server-side), not in the browser.
- *
- * Each line is individually wrapped because Wasp reads child process
- * output line-by-line and re-prints it with a prefix (e.g. `[ Server ]`).
- * A single color code spanning multiple lines would only color the first line.
- *
- * @example
- * ```typescript
- * console.log(colorize('red', 'This is red text'));
- * ```
- *
- * @internal This is a private API for: SDK, client.
- */
-export function colorize(
-  color: keyof typeof ansiColorCodes,
-  text: string,
-): string {
-  if (!supportsAnsiFormatting()) {
-    return text;
-  }
-
-  const ansiColorCode = ansiColorCodes[color];
-  return text
-    .split("\n")
-    .map((line) => `${ansiColorCode}${line}${ansiResetCode}`)
-    .join("\n");
-}
-
-function supportsAnsiFormatting(): boolean {
-  const isBrowser = !!globalThis.window;
-  const isNode = !!globalThis.process;
-
-  if (isBrowser && "chrome" in window) {
-    return true;
-  }
-  if (isNode) {
-    if ("NO_COLOR" in process.env) {
-      return false;
-    }
-    // Wasp runs the server as a child process with piped stdout/stderr,
-    // so streams are not TTYs and hasColors() won't exist on them.
-    // We default to true for non-browser runtimes because Wasp's CLI
-    // handles the final terminal output and supports ANSI codes.
-    return true;
-  }
-
-  return false;
-}
-
-const ansiColorCodes = {
-  red: "\x1b[31m",
-  yellow: "\x1b[33m",
-} as const;
-
-const ansiResetCode = "\x1b[0m";

package/data/Generator/templates/sdk/wasp/universal/predicates.ts

@@ -1,3 +0,0 @@
-export function isNotNull<T>(value: T | null): value is T {
-  return value !== null;
-}

package/data/Generator/templates/sdk/wasp/universal/types.ts

@@ -1,74 +0,0 @@
-// This is a helper type used exclusively for DX purposes. It's a No-op for the
-// compiler, but expands the type's representatoin in IDEs (i.e., inlines all
-// type constructors) to make it more readable for the user.
-//
-// It expands this SO answer to functions: https://stackoverflow.com/a/57683652
-export type Expand<T> = T extends (...args: infer A) => infer R
-  ? (...args: A) => R
-  : T extends infer O
-  ? { [K in keyof O]: O[K] }
-  : never
-
-// TypeScript's native Awaited type exhibits strange behavior in VS Code (see
-// https://github.com/wasp-lang/wasp/pull/1090#discussion_r1159687537 for
-// details). Until it's fixed, we're using our own type for this.
-//
-// TODO: investigate further. This most likely has something to do with an
-// unsatisfied 'extends' constraints. A mismatch is probably happening with
-// function parameter types and/or return types (check '_ReturnType' below for
-// more).
-export type _Awaited<T> = T extends Promise<infer V>
-  ? _Awaited<V>
-  : T
-
-// TypeScript's native ReturnType does not work for functions of type '(...args:
-// never[]) => unknown' (and that's what operations currently use).
-//
-// TODO: investigate how to properly specify the 'extends' constraint for function
-// type (i.e., any vs never and unknown) and stick with that. Take DX into
-// consideration.
-export type _ReturnType<T extends (...args: never[]) => unknown> =
-  T extends (...args: never[]) => infer R ? R : never
-
-
-// Returns elements of an array except the first one.
-export type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
-
-
-// Source: https://stackoverflow.com/a/55541672
-export type IfAny<Value, Then, Else> = 0 extends (1 & Value) ? Then : Else;
-
-// If users use JS to define their operations and destructure object arguments,
-// Wasp's TS helper types can't infer correct types due to this TS bug:
-// https://github.com/microsoft/TypeScript/issues/52768 
-// The bug breaks the built-in `Parameters` helper, so we introduce a custom version
-// that works with Wasp's TS helper types like `EntityMapFor`.
-export type _Parameters<T extends (...args: any) => any> = T extends (
-  firstParam: infer FirstParam,
-  ...rest: infer Rest
-) => any
-  ? [FirstParam, ...Rest]
-  : Parameters<T>;
-
-/**
- * 
- * Exact ensures a type has exactly the properties of another type.
- * Helps with simulating excess property checking for generics in function definitions.
- * 
- * Inspired by: https://stackoverflow.com/questions/49580725/is-it-possible-to-restrict-typescript-object-to-contain-only-properties-define
- * 
- * @template T - The base type that defines the allowed properties
- * @template U - The type to be constrained (must extend T)
- * 
- * @example
- * // User can no longer add properties outside of UserSignupFields to T
- * function defineUserSignupFields<T extends UserSignupFields>(
- *   fields: Exact<UserSignupFields, T>
- * ): T {
- *   return fields
- * }
- */
-export type Exact<T, U extends T = T> = U & {
-  [P in Exclude<keyof U, keyof T>]: never;
-}
-

package/data/Generator/templates/sdk/wasp/universal/url.ts

@@ -1,9 +0,0 @@
-export function stripTrailingSlash(url: string): string
-export function stripTrailingSlash(url: undefined): undefined
-export function stripTrailingSlash(url?: string): string | undefined {
-    return url?.replace(/\/$/, "");
-}
-
-export function getOrigin(url: string) {
-    return new URL(url).origin;
-}

package/data/Generator/templates/sdk/wasp/universal/validators.ts

@@ -1,21 +0,0 @@
-export function isValidAbsoluteURL(rawUrl: string): boolean {
-    try {
-        const url = new URL(rawUrl);
-        /*
-            URL constructor will parse some invalid absolute URLs as valid URLs
-            so we need to do some extra checks.
-
-            Example: "localhost:3000" will be parsed as URL with protocol of
-            "localhost:" and host of "3000"
-        */
-        return url.protocol === "http:" || url.protocol === "https:";
-    } catch (e) {
-        return false;
-    }
-}
-
-export function throwIfNotValidAbsoluteURL(value: string | undefined, name: string): void {
-    if (value && !isValidAbsoluteURL(value)) {
-        throw new Error(`${name} must be a valid absolute URL`);
-    }
-}

package/data/packages/ts-inspect/dist/exports.js

@@ -1,82 +0,0 @@
-import * as fs from "fs/promises";
-import JSON5 from "json5";
-import * as path from "path";
-import ts from "typescript";
-import * as z from "zod";
-export const ExportsRequest = z.object({
-    tsconfig: z.string().optional(),
-    filepaths: z.array(z.string()),
-});
-export const ExportsRequests = z.array(ExportsRequest);
-export async function getExportsOfFiles(request) {
-    let compilerOptions = {};
-    // If a tsconfig is given, load the configuration.
-    if (request.tsconfig) {
-        compilerOptions = await loadCompilerOptionsFromTsConfig(request.tsconfig);
-    }
-    const exportsMap = {};
-    // Initialize the TS compiler.
-    const program = ts.createProgram(request.filepaths, compilerOptions);
-    const checker = program.getTypeChecker();
-    // Loop through each given file and try to get its exports.
-    for (let filename of request.filepaths) {
-        try {
-            exportsMap[filename] = getExportsOfFile(program, checker, filename);
-        }
-        catch (err) {
-            console.error(err);
-            exportsMap[filename] = [];
-        }
-    }
-    return exportsMap;
-}
-async function loadCompilerOptionsFromTsConfig(tsconfig) {
-    const configJson = JSON5.parse(await fs.readFile(tsconfig, "utf8"));
-    const basePath = path.dirname(tsconfig);
-    const { options, errors } = ts.convertCompilerOptionsFromJson(configJson.compilerOptions, basePath, tsconfig);
-    if (errors && errors.length) {
-        throw errors;
-    }
-    return options;
-}
-function getExportsOfFile(program, checker, filename) {
-    const source = program.getSourceFile(filename);
-    if (!source) {
-        throw new Error(`Error getting source for ${filename}`);
-    }
-    const moduleSymbol = checker.getSymbolAtLocation(source);
-    if (!moduleSymbol) {
-        // This is caused by errors within the TS file, so we say there are no exports.
-        return [];
-    }
-    const exportSymbols = checker.getExportsOfModule(moduleSymbol);
-    return exportSymbols.map((exp) => getExportForExportSymbol(program, checker, exp));
-}
-function getExportForExportSymbol(program, checker, exportSymbol) {
-    let range = undefined;
-    // Try to get the location information from the first value declaration for
-    // the export. If there are no value declarations, we don't return any location
-    // info for this export and `range` remains undefined.
-    if (exportSymbol.valueDeclaration) {
-        // NOTE: This isn't a very robust way of getting the location: it will always
-        // point to the line that has `export`, rather than the line where the exported
-        // symbol is defined.
-        const startOffset = exportSymbol.valueDeclaration.getStart();
-        const startPos = ts.getLineAndCharacterOfPosition(exportSymbol.valueDeclaration.getSourceFile(), startOffset);
-        const endOffset = exportSymbol.valueDeclaration.getEnd();
-        const endPos = ts.getLineAndCharacterOfPosition(exportSymbol.valueDeclaration.getSourceFile(), endOffset);
-        range = {
-            start: { line: startPos.line, column: startPos.character },
-            end: { line: endPos.line, column: endPos.character },
-        };
-    }
-    // Convert export to the output format.
-    const exportName = exportSymbol.getName();
-    if (exportName === "default") {
-        return { type: "default", range };
-    }
-    else {
-        return { type: "named", name: exportName, range };
-    }
-}
-//# sourceMappingURL=exports.js.map

package/data/packages/ts-inspect/dist/index.js

@@ -1,28 +0,0 @@
-import { ExportsRequests, getExportsOfFiles } from "./exports.js";
-async function readAllFromStdin() {
-    return new Promise((resolve, reject) => {
-        let chunks = "";
-        process.stdin.on("data", (data) => {
-            chunks += data;
-        });
-        process.stdin.on("end", () => resolve(chunks));
-        process.stdin.on("close", () => resolve(chunks));
-        process.stdin.on("error", (err) => reject(err));
-    });
-}
-async function main() {
-    const inputStr = await readAllFromStdin();
-    const input = JSON.parse(inputStr);
-    const requests = ExportsRequests.parse(input);
-    let exports = {};
-    for (let request of requests) {
-        const newExports = await getExportsOfFiles(request);
-        exports = { ...exports, ...newExports };
-    }
-    console.log(JSON.stringify(exports));
-}
-main().catch((err) => {
-    console.error(err);
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map