alinea 0.3.2 → 0.4.0-preview.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 alineacms
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/alinea.d.ts

@@ -1,4 +1,3 @@
-import { Schema } from '@alinea/core';
-export { createConfig, root, schema, type, workspace } from '@alinea/core';
-export * from './input';
-export declare type infer<T> = Schema.TypeOf<T>;
+export { createConfig, Meta as meta, page, root, schema, type, workspace } from 'alinea/core';
+export { createMediaRoot as media } from 'alinea/core/media/MediaRoot';
+export * from './input.js';

package/dist/alinea.js

@@ -1,8 +1,22 @@
-// packages/alinea/src/alinea.ts
-import { createConfig, root, schema, type, workspace } from "@alinea/core";
+import "./chunks/chunk-U5RRZUYZ.js";
+
+// src/alinea.ts
+import {
+  createConfig,
+  Meta,
+  page,
+  root,
+  schema,
+  type,
+  workspace
+} from "alinea/core";
+import { createMediaRoot } from "alinea/core/media/MediaRoot";
 export * from "./input.js";
 export {
   createConfig,
+  createMediaRoot as media,
+  Meta as meta,
+  page,
   root,
   schema,
   type,

package/dist/auth/passwordless/PasswordLessAuth.server.d.ts

@@ -0,0 +1,19 @@
+import { Handler } from 'alinea/backend/router/Router';
+import { Auth, Connection, User } from 'alinea/core';
+import type { Transporter } from 'nodemailer';
+export type PasswordLessAuthOptions = {
+    dashboardUrl: string;
+    subject: string;
+    from: string;
+    transporter: Transporter;
+    jwtSecret: string;
+    isUser: (email: string) => Promise<boolean>;
+};
+export declare class PasswordLessAuth implements Auth.Server {
+    protected options: PasswordLessAuthOptions;
+    handler: Handler<Request, Response | undefined>;
+    users: WeakMap<Request, User>;
+    constructor(options: PasswordLessAuthOptions);
+    contextFor(request: Request): Promise<Connection.AuthContext>;
+    userFor(request: Request): Promise<User>;
+}

package/dist/auth/passwordless/PasswordLessAuth.server.js

@@ -0,0 +1,329 @@
+import "../../chunks/chunk-U5RRZUYZ.js";
+
+// src/auth/passwordless/PasswordLessAuth.server.ts
+import { router } from "alinea/backend/router/Router";
+import { Connection, HttpError, Outcome } from "alinea/core";
+import { sign, verify } from "alinea/core/util/JWT";
+
+// node_modules/superstruct/dist/index.mjs
+var StructError = class extends TypeError {
+  constructor(failure, failures) {
+    let cached;
+    const { message, explanation, ...rest } = failure;
+    const { path } = failure;
+    const msg = path.length === 0 ? message : `At path: ${path.join(".")} -- ${message}`;
+    super(explanation ?? msg);
+    if (explanation != null)
+      this.cause = msg;
+    Object.assign(this, rest);
+    this.name = this.constructor.name;
+    this.failures = () => {
+      return cached ?? (cached = [failure, ...failures()]);
+    };
+  }
+};
+function isIterable(x) {
+  return isObject(x) && typeof x[Symbol.iterator] === "function";
+}
+function isObject(x) {
+  return typeof x === "object" && x != null;
+}
+function print(value) {
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  return typeof value === "string" ? JSON.stringify(value) : `${value}`;
+}
+function shiftIterator(input) {
+  const { done, value } = input.next();
+  return done ? void 0 : value;
+}
+function toFailure(result, context, struct, value) {
+  if (result === true) {
+    return;
+  } else if (result === false) {
+    result = {};
+  } else if (typeof result === "string") {
+    result = { message: result };
+  }
+  const { path, branch } = context;
+  const { type } = struct;
+  const { refinement, message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ""}, but received: \`${print(value)}\`` } = result;
+  return {
+    value,
+    type,
+    refinement,
+    key: path[path.length - 1],
+    path,
+    branch,
+    ...result,
+    message
+  };
+}
+function* toFailures(result, context, struct, value) {
+  if (!isIterable(result)) {
+    result = [result];
+  }
+  for (const r of result) {
+    const failure = toFailure(r, context, struct, value);
+    if (failure) {
+      yield failure;
+    }
+  }
+}
+function* run(value, struct, options = {}) {
+  const { path = [], branch = [value], coerce = false, mask: mask2 = false } = options;
+  const ctx = { path, branch };
+  if (coerce) {
+    value = struct.coercer(value, ctx);
+    if (mask2 && struct.type !== "type" && isObject(struct.schema) && isObject(value) && !Array.isArray(value)) {
+      for (const key in value) {
+        if (struct.schema[key] === void 0) {
+          delete value[key];
+        }
+      }
+    }
+  }
+  let status = "valid";
+  for (const failure of struct.validator(value, ctx)) {
+    failure.explanation = options.message;
+    status = "not_valid";
+    yield [failure, void 0];
+  }
+  for (let [k, v, s] of struct.entries(value, ctx)) {
+    const ts = run(v, s, {
+      path: k === void 0 ? path : [...path, k],
+      branch: k === void 0 ? branch : [...branch, v],
+      coerce,
+      mask: mask2,
+      message: options.message
+    });
+    for (const t of ts) {
+      if (t[0]) {
+        status = t[0].refinement != null ? "not_refined" : "not_valid";
+        yield [t[0], void 0];
+      } else if (coerce) {
+        v = t[1];
+        if (k === void 0) {
+          value = v;
+        } else if (value instanceof Map) {
+          value.set(k, v);
+        } else if (value instanceof Set) {
+          value.add(v);
+        } else if (isObject(value)) {
+          if (v !== void 0 || k in value)
+            value[k] = v;
+        }
+      }
+    }
+  }
+  if (status !== "not_valid") {
+    for (const failure of struct.refiner(value, ctx)) {
+      failure.explanation = options.message;
+      status = "not_refined";
+      yield [failure, void 0];
+    }
+  }
+  if (status === "valid") {
+    yield [void 0, value];
+  }
+}
+var Struct = class {
+  constructor(props) {
+    const { type, schema, validator, refiner, coercer = (value) => value, entries = function* () {
+    } } = props;
+    this.type = type;
+    this.schema = schema;
+    this.entries = entries;
+    this.coercer = coercer;
+    if (validator) {
+      this.validator = (value, context) => {
+        const result = validator(value, context);
+        return toFailures(result, context, this, value);
+      };
+    } else {
+      this.validator = () => [];
+    }
+    if (refiner) {
+      this.refiner = (value, context) => {
+        const result = refiner(value, context);
+        return toFailures(result, context, this, value);
+      };
+    } else {
+      this.refiner = () => [];
+    }
+  }
+  /**
+   * Assert that a value passes the struct's validation, throwing if it doesn't.
+   */
+  assert(value, message) {
+    return assert(value, this, message);
+  }
+  /**
+   * Create a value with the struct's coercion logic, then validate it.
+   */
+  create(value, message) {
+    return create(value, this, message);
+  }
+  /**
+   * Check if a value passes the struct's validation.
+   */
+  is(value) {
+    return is(value, this);
+  }
+  /**
+   * Mask a value, coercing and validating it, but returning only the subset of
+   * properties defined by the struct's schema.
+   */
+  mask(value, message) {
+    return mask(value, this, message);
+  }
+  /**
+   * Validate a value with the struct's validation logic, returning a tuple
+   * representing the result.
+   *
+   * You may optionally pass `true` for the `withCoercion` argument to coerce
+   * the value before attempting to validate it. If you do, the result will
+   * contain the coerced result when successful.
+   */
+  validate(value, options = {}) {
+    return validate(value, this, options);
+  }
+};
+function assert(value, struct, message) {
+  const result = validate(value, struct, { message });
+  if (result[0]) {
+    throw result[0];
+  }
+}
+function create(value, struct, message) {
+  const result = validate(value, struct, { coerce: true, message });
+  if (result[0]) {
+    throw result[0];
+  } else {
+    return result[1];
+  }
+}
+function mask(value, struct, message) {
+  const result = validate(value, struct, { coerce: true, mask: true, message });
+  if (result[0]) {
+    throw result[0];
+  } else {
+    return result[1];
+  }
+}
+function is(value, struct) {
+  const result = validate(value, struct);
+  return !result[0];
+}
+function validate(value, struct, options = {}) {
+  const tuples = run(value, struct, options);
+  const tuple = shiftIterator(tuples);
+  if (tuple[0]) {
+    const error = new StructError(tuple[0], function* () {
+      for (const t of tuples) {
+        if (t[0]) {
+          yield t[0];
+        }
+      }
+    });
+    return [error, void 0];
+  } else {
+    const v = tuple[1];
+    return [void 0, v];
+  }
+}
+function define(name, validator) {
+  return new Struct({ type: name, schema: null, validator });
+}
+function never() {
+  return define("never", () => false);
+}
+function object(schema) {
+  const knowns = schema ? Object.keys(schema) : [];
+  const Never = never();
+  return new Struct({
+    type: "object",
+    schema: schema ? schema : null,
+    *entries(value) {
+      if (schema && isObject(value)) {
+        const unknowns = new Set(Object.keys(value));
+        for (const key of knowns) {
+          unknowns.delete(key);
+          yield [key, value[key], schema[key]];
+        }
+        for (const key of unknowns) {
+          yield [key, value[key], Never];
+        }
+      }
+    },
+    validator(value) {
+      return isObject(value) || `Expected an object, but received: ${print(value)}`;
+    },
+    coercer(value) {
+      return isObject(value) ? { ...value } : value;
+    }
+  });
+}
+function string() {
+  return define("string", (value) => {
+    return typeof value === "string" || `Expected a string, but received: ${print(value)}`;
+  });
+}
+
+// src/auth/passwordless/PasswordLessAuth.server.ts
+var LoginBody = object({
+  email: string()
+});
+var PasswordLessAuth = class {
+  constructor(options) {
+    this.options = options;
+    const matcher = router.startAt(Connection.routes.base);
+    this.handler = router(
+      matcher.post(Connection.routes.base + "/auth.passwordless").map(router.parseJson).map(async ({ body }) => {
+        assert(body, LoginBody);
+        const email = body.email;
+        const isUser = await this.options.isUser(email);
+        if (!isUser)
+          return Outcome.Failure(new HttpError(404, "User not found"));
+        const token = await sign({ sub: email }, this.options.jwtSecret);
+        const url = `${this.options.dashboardUrl}?token=${token}`;
+        await this.options.transporter.sendMail({
+          from: this.options.from,
+          to: body.email,
+          subject: this.options.subject,
+          text: url
+        });
+        return Outcome.Success("Sent");
+      }).map(router.jsonResponse),
+      router.use(async (request) => {
+        try {
+          const user = await this.userFor(request);
+        } catch (e) {
+          return Outcome.Failure(new HttpError(401, "Unauthorized"));
+        }
+      }).map(router.jsonResponse)
+    ).recover(router.reportError);
+  }
+  handler;
+  users = /* @__PURE__ */ new WeakMap();
+  async contextFor(request) {
+    return { user: await this.userFor(request) };
+  }
+  async userFor(request) {
+    if (this.users.has(request))
+      return this.users.get(request);
+    const authHeader = request.headers.get("Authorization");
+    if (!authHeader)
+      throw new HttpError(400, "No Authorization header");
+    const [scheme, token] = authHeader.split(" ");
+    if (scheme !== "Bearer")
+      throw new HttpError(400, "Invalid Authorization header");
+    const user = await verify(token, this.options.jwtSecret);
+    this.users.set(request, user);
+    return user;
+  }
+};
+export {
+  PasswordLessAuth
+};

package/dist/auth/passwordless/PasswordLessLogin.d.ts

@@ -0,0 +1,2 @@
+import { Auth } from 'alinea/core';
+export declare function PasswordLessLogin({ setSession }: Auth.ViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/auth/passwordless/PasswordLessLogin.js

@@ -0,0 +1,182 @@
+import "../../chunks/chunk-U5RRZUYZ.js";
+
+// src/auth/passwordless/PasswordLessLogin.tsx
+import { Connection } from "alinea/core";
+import { Client } from "alinea/core/Client";
+import { decode } from "alinea/core/util/JWT";
+import { joinPaths } from "alinea/core/util/Urls";
+import { useDashboard } from "alinea/dashboard/hook/UseDashboard";
+import { Head } from "alinea/dashboard/util/Head";
+import { Button, Loader, Typo, fromModule, px } from "alinea/ui";
+import { HStack, VStack } from "alinea/ui/Stack";
+import { LogoShape } from "alinea/ui/branding/LogoShape";
+import { IcRoundArrowBack } from "alinea/ui/icons/IcRoundArrowBack";
+import { IcRoundArrowForward } from "alinea/ui/icons/IcRoundArrowForward";
+import { RiFlashlightFill } from "alinea/ui/icons/RiFlashlightFill";
+import { useLayoutEffect, useState } from "react";
+
+// src/auth/passwordless/PasswordLessLogin.module.scss
+var PasswordLessLogin_module_default = {
+  "root-email": "alinea-PasswordLessLogin-email",
+  "rootEmail": "alinea-PasswordLessLogin-email",
+  "root-email-input": "alinea-PasswordLessLogin-email-input",
+  "rootEmailInput": "alinea-PasswordLessLogin-email-input"
+};
+
+// src/auth/passwordless/PasswordLessLogin.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var styles = fromModule(PasswordLessLogin_module_default);
+function LoginBox({ children }) {
+  return /* @__PURE__ */ jsx("div", { style: { width: px(320) }, children: /* @__PURE__ */ jsx(VStack, { gap: 16, children }) });
+}
+function LoginHeader({ children }) {
+  return /* @__PURE__ */ jsxs(HStack, { center: true, gap: 16, children: [
+    /* @__PURE__ */ jsx(LogoShape, { children: /* @__PURE__ */ jsx(RiFlashlightFill, {}) }),
+    /* @__PURE__ */ jsx(Typo.H1, { flat: true, children })
+  ] });
+}
+function LoginForm({ onSubmit, email, setEmail }) {
+  function handleSubmit(e) {
+    e.preventDefault();
+    onSubmit();
+  }
+  return /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, children: /* @__PURE__ */ jsxs(LoginBox, { children: [
+    /* @__PURE__ */ jsx(LoginHeader, { children: "Log in" }),
+    /* @__PURE__ */ jsxs(VStack, { gap: 10, children: [
+      /* @__PURE__ */ jsx(Typo.P, { flat: true, children: "We'll send you a login link by mail." }),
+      /* @__PURE__ */ jsxs(HStack, { center: true, gap: 16, children: [
+        /* @__PURE__ */ jsx("div", { className: styles.root.email(), children: /* @__PURE__ */ jsx(
+          "input",
+          {
+            className: styles.root.email.input(),
+            type: "email",
+            placeholder: "Email address",
+            required: true,
+            value: email,
+            onChange: (e) => setEmail(e.target.value)
+          }
+        ) }),
+        /* @__PURE__ */ jsx(Button, { size: "large", type: "submit", children: /* @__PURE__ */ jsxs(HStack, { center: true, gap: 8, children: [
+          /* @__PURE__ */ jsx("span", { children: "Sign in" }),
+          /* @__PURE__ */ jsx(IcRoundArrowForward, {})
+        ] }) })
+      ] })
+    ] })
+  ] }) });
+}
+function LoginScreen(props) {
+  switch (props.state) {
+    case 0 /* Loading */:
+      return /* @__PURE__ */ jsx(Loader, {});
+    case 1 /* Input */:
+      return /* @__PURE__ */ jsx(LoginForm, { ...props });
+    case 2 /* Sent */:
+      return /* @__PURE__ */ jsxs(LoginBox, { children: [
+        /* @__PURE__ */ jsx(LoginHeader, { children: "Check your email" }),
+        /* @__PURE__ */ jsxs(Typo.P, { children: [
+          "We've sent you link at ",
+          props.email
+        ] })
+      ] });
+    case 3 /* NotFound */:
+      return /* @__PURE__ */ jsxs(LoginBox, { children: [
+        /* @__PURE__ */ jsx(LoginHeader, { children: "Oops" }),
+        /* @__PURE__ */ jsxs(Typo.P, { flat: true, children: [
+          'The email adress "',
+          props.email,
+          '" is not known'
+        ] }),
+        /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(Button, { onClick: () => props.setState(1 /* Input */), children: /* @__PURE__ */ jsxs(HStack, { center: true, gap: 8, children: [
+          /* @__PURE__ */ jsx(IcRoundArrowBack, {}),
+          /* @__PURE__ */ jsx("span", { children: "Try again" })
+        ] }) }) })
+      ] });
+    case 4 /* Error */:
+      return /* @__PURE__ */ jsxs(LoginBox, { children: [
+        /* @__PURE__ */ jsx(LoginHeader, { children: "Oops" }),
+        /* @__PURE__ */ jsx(Typo.P, { children: "Something went wrong, please try again later" })
+      ] });
+  }
+}
+function useResolveToken(setSession) {
+  const { client } = useDashboard();
+  useLayoutEffect(() => {
+    const params = new URLSearchParams(window.location.search);
+    const isTokenFromUrl = params.has("token");
+    const token = params.get("token") || localStorage.getItem("@alinea/auth.passwordless");
+    if (token) {
+      let logout2 = function() {
+        localStorage.removeItem("@alinea/auth.passwordless");
+        setSession(void 0);
+      }, applyAuth2 = function(init) {
+        return {
+          ...init,
+          headers: { ...init?.headers, authorization: `Bearer ${token}` }
+        };
+      };
+      var logout = logout2, applyAuth = applyAuth2;
+      const user = token && decode(token);
+      if (!(client instanceof Client))
+        throw new Error(`Cannot authenticate with non http client`);
+      setSession({
+        user,
+        cnx: client.authenticate(applyAuth2, logout2),
+        end: async () => logout2()
+      });
+      if (isTokenFromUrl) {
+        localStorage.setItem("@alinea/auth.passwordless", token);
+        history.pushState(null, "", window.location.pathname);
+      }
+    }
+  }, []);
+}
+function PasswordLessLogin({ setSession }) {
+  const { client } = useDashboard();
+  const [state, setState] = useState(1 /* Input */);
+  const [email, setEmail] = useState("");
+  useResolveToken(setSession);
+  function handleSubmit() {
+    setState(0 /* Loading */);
+    if (!(client instanceof Client))
+      throw new Error(`Cannot authenticate with non http client`);
+    fetch(
+      joinPaths(
+        client.options.url,
+        Connection.routes.base,
+        `/auth.passwordless`
+      ),
+      {
+        headers: { "content-type": "application/json" },
+        method: "POST",
+        body: JSON.stringify({ email })
+      }
+    ).then((res) => {
+      switch (res.status) {
+        case 200:
+          return setState(2 /* Sent */);
+        case 404:
+          return setState(3 /* NotFound */);
+        default:
+          return setState(4 /* Error */);
+      }
+    }).catch(() => {
+      setState(4 /* Error */);
+    });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Head, { children: /* @__PURE__ */ jsx("title", { children: "Log in" }) }),
+    /* @__PURE__ */ jsx("div", { style: { display: "flex", height: "100%", width: "100%" }, children: /* @__PURE__ */ jsx("div", { style: { margin: "auto", padding: px(20) }, children: /* @__PURE__ */ jsx(
+      LoginScreen,
+      {
+        state,
+        setState,
+        onSubmit: handleSubmit,
+        email,
+        setEmail
+      }
+    ) }) })
+  ] });
+}
+export {
+  PasswordLessLogin
+};

package/dist/auth/passwordless.d.ts

@@ -0,0 +1,4 @@
+import { PasswordLessAuthOptions } from 'alinea/auth/passwordless/PasswordLessAuth';
+import { Auth } from 'alinea/core';
+export type PasswordLess = PasswordLessAuthOptions;
+export declare const passwordLess: Auth<PasswordLessAuthOptions>;

package/dist/auth/passwordless.js

@@ -0,0 +1,14 @@
+import "../chunks/chunk-U5RRZUYZ.js";
+
+// src/auth/passwordless.ts
+import {
+  PasswordLessAuth
+} from "alinea/auth/passwordless/PasswordLessAuth";
+import { PasswordLessLogin } from "./passwordless/PasswordLessLogin.js";
+var passwordLess = {
+  view: PasswordLessLogin,
+  configure: (options) => new PasswordLessAuth(options)
+};
+export {
+  passwordLess
+};

package/dist/backend/Database.d.ts

@@ -0,0 +1,73 @@
+import { Config, EntryUrlMeta, PageSeed, Syncable, Type } from 'alinea/core';
+import { EntryRecord } from 'alinea/core/EntryRecord';
+import { Mutation } from 'alinea/core/Mutation';
+import { Driver, Table } from 'rado';
+import { EntryPhase, EntryRow } from '../core/EntryRow.js';
+import { Source } from './Source.js';
+import { Store } from './Store.js';
+import { Target } from './Target.js';
+import { AlineaMeta } from './db/AlineaMeta.js';
+type Seed = {
+    type: string;
+    workspace: string;
+    root: string;
+    filePath: string;
+    page: PageSeed;
+};
+export declare class Database implements Syncable {
+    protected store: Store;
+    config: Config;
+    seed: Map<string, Seed>;
+    constructor(store: Store, config: Config);
+    updates(request: AlineaMeta): Promise<{
+        contentHash: string;
+        entries: {
+            entryId: string;
+            phase: EntryPhase;
+            title: string;
+            type: string;
+            seeded: boolean;
+            workspace: string;
+            root: string;
+            level: number;
+            filePath: string;
+            parentDir: string;
+            childrenDir: string | null;
+            index: string;
+            parent: string | null;
+            i18nId: string;
+            locale: string | null;
+            modifiedAt: number;
+            contentHash: string;
+            active: boolean;
+            main: boolean;
+            path: string;
+            url: string;
+            data: any;
+            searchableText: string;
+        }[];
+    }>;
+    versionIds(): Promise<Array<string>>;
+    syncWith(remote: Syncable): Promise<Array<string>>;
+    updateEntries(entries: Array<EntryRow>): Promise<void>;
+    applyMutations(mutations: Array<Mutation>): Promise<void>;
+    meta(): Promise<{
+        contentHash: string;
+        modifiedAt: number;
+    }>;
+    static index(query: Driver.Async): Promise<{
+        rowsAffected: number;
+    }>;
+    private writeMeta;
+    inited: boolean;
+    private init;
+    entryUrl(type: Type, meta: EntryUrlMeta): string;
+    computeEntry(data: EntryRecord, meta: {
+        workspace: string;
+        root: string;
+        filePath: string;
+    }, seed?: Seed): Omit<Table.Insert<typeof EntryRow>, 'contentHash'>;
+    seedData(): Map<string, Seed>;
+    fill(source: Source, target?: Target): Promise<void>;
+}
+export {};