@adonisjs/ally/build/index.js

Social authentication provider for AdonisJS

import {
  Oauth1Driver
} from "./chunk-VHORNQLN.js";
import {
  AllyManager
} from "./chunk-NZT2DLWM.js";
import {
  Oauth2Driver
} from "./chunk-GWAQFMNS.js";
import {
  RedirectRequest,
  errors_exports
} from "./chunk-N72DEJC2.js";
import "./chunk-PZ5AY32C.js";

// index.ts
import { HttpClient } from "@poppinss/oauth-client";

// stubs/main.ts
import { getDirname } from "@poppinss/utils";
var stubsRoot = getDirname(import.meta.url);

// configure.ts
var AVAILABLE_PROVIDERS = [
  "discord",
  "facebook",
  "github",
  "google",
  "linkedin",
  "linkedinOpenidConnect",
  "spotify",
  "twitter"
];
async function configure(command) {
  let selectedProviders = command.parsedFlags.providers;
  if (!selectedProviders) {
    selectedProviders = await command.prompt.multiple(
      "Select the social auth providers you plan to use",
      AVAILABLE_PROVIDERS,
      {
        validate(value) {
          return !value || !value.length ? "Select a social provider to configure the package" : true;
        }
      }
    );
  }
  let providers = typeof selectedProviders === "string" ? [selectedProviders] : selectedProviders;
  const unknownProvider = providers.find((provider) => !AVAILABLE_PROVIDERS.includes(provider));
  if (unknownProvider) {
    command.exitCode = 1;
    command.logger.error(`Invalid social provider "${unknownProvider}"`);
    return;
  }
  const codemods = await command.createCodemods();
  await codemods.makeUsingStub(stubsRoot, "config/ally.stub", {
    providers: providers.map((provider) => {
      return { provider, envPrefix: provider.toUpperCase() };
    })
  });
  await codemods.updateRcFile((rcFile) => {
    rcFile.addProvider("@adonisjs/ally/ally_provider");
  });
  await codemods.defineEnvVariables(
    providers.reduce((result, provider) => {
      result[`${provider.toUpperCase()}_CLIENT_ID`] = "";
      result[`${provider.toUpperCase()}_CLIENT_SECRET`] = "";
      return result;
    }, {})
  );
  await codemods.defineEnvValidations({
    variables: providers.reduce((result, provider) => {
      result[`${provider.toUpperCase()}_CLIENT_ID`] = "Env.schema.string()";
      result[`${provider.toUpperCase()}_CLIENT_SECRET`] = "Env.schema.string()";
      return result;
    }, {}),
    leadingComment: "Variables for configuring ally package"
  });
}

// src/define_config.ts
import { configProvider } from "@adonisjs/core";
function defineConfig(config) {
  return configProvider.create(async (app) => {
    const serviceNames = Object.keys(config);
    const services2 = {};
    for (let serviceName of serviceNames) {
      const service = config[serviceName];
      if (typeof service === "function") {
        services2[serviceName] = service;
      } else {
        services2[serviceName] = await service.resolver(app);
      }
    }
    return services2;
  });
}
var services = {
  discord(config) {
    return configProvider.create(async () => {
      const { DiscordDriver } = await import("./src/drivers/discord.js");
      return (ctx) => new DiscordDriver(ctx, config);
    });
  },
  facebook(config) {
    return configProvider.create(async () => {
      const { FacebookDriver } = await import("./src/drivers/facebook.js");
      return (ctx) => new FacebookDriver(ctx, config);
    });
  },
  github(config) {
    return configProvider.create(async () => {
      const { GithubDriver } = await import("./src/drivers/github.js");
      return (ctx) => new GithubDriver(ctx, config);
    });
  },
  google(config) {
    return configProvider.create(async () => {
      const { GoogleDriver } = await import("./src/drivers/google.js");
      return (ctx) => new GoogleDriver(ctx, config);
    });
  },
  linkedin(config) {
    return configProvider.create(async () => {
      const { LinkedInDriver } = await import("./src/drivers/linked_in.js");
      return (ctx) => new LinkedInDriver(ctx, config);
    });
  },
  linkedinOpenidConnect(config) {
    return configProvider.create(async () => {
      const { LinkedInOpenidConnectDriver } = await import("./src/drivers/linked_in_openid_connect.js");
      return (ctx) => new LinkedInOpenidConnectDriver(ctx, config);
    });
  },
  spotify(config) {
    return configProvider.create(async () => {
      const { SpotifyDriver } = await import("./src/drivers/spotify.js");
      return (ctx) => new SpotifyDriver(ctx, config);
    });
  },
  twitter(config) {
    return configProvider.create(async () => {
      const { TwitterDriver } = await import("./src/drivers/twitter.js");
      return (ctx) => new TwitterDriver(ctx, config);
    });
  }
};
export {
  AllyManager,
  HttpClient as ApiRequest,
  Oauth1Driver,
  Oauth2Driver,
  RedirectRequest,
  configure,
  defineConfig,
  errors_exports as errors,
  services,
  stubsRoot
};
//# sourceMappingURL=index.js.map