小编Dac*_*d3r的帖子

我正在为我的项目使用Aurelia骨架.一切看起来都很直观,但是我遇到了一个我怀疑相当容易的问题(如果你知道的话).

问题是app.html/app.js最初显示导航栏并加载一些默认样式.

现在我需要一个登录页面,它不会加载任何东西,除了它自己的样式,没有导航栏没有任何东西 - 只是它自己的登录表单.

所以我尝试过这样的事情:

app.js

<template>
    <div if.bind="auth.isNotAuthenticated()">
        <require from="components/login/index" ></require>
        <login router.bind="router"></login>
    </div> 
    <div if.bind="auth.isAuthenticated()">
        <require from="nav-bar.html" ></require>
        <require from="../styles/styles.css"></require>
        <div class="container" id="banner">
            <div class="row">
                <img src="images/logo.png" />
            </div>
        </div>
        <nav-bar router.bind="router"></nav-bar>
        <div class="page-host">
            <router-view></router-view>
        </div>
    </div>
</template>

显然这不起作用(除非你刷新页面/ f5),因为app.js/app.html是始终存在且永不改变的根路由.但我希望标记中的逻辑有助于说明我想要解决的问题？

我猜我只知道当我从登录路线(登录成功)导航到另一条路线时,如何重新加载父路线(app.js).当我退出时,父路线(app.js)也应该再次刷新.然后我的所有问题都将得到解决.

我在这里错过了什么？:-)

你可能知道有一个名为ltree的PostgreSQL模块.此外,您还可以使用数组类型作为整数(*1,请参阅下面的注释),在此测试中显示,与ltree相比,其递归查询实际上执行速度稍慢 - 除了字符串索引(*2,见下面的评论).

我不太确定这些测试结果的可信度.

这里我最大的问题实际上是关于相对未知的,几乎没有文档的树模块.这里描述(文档也可以找到!!)如下:

支持分层数据类型(类型的词典树),应该转到contrib/tree,因为缺少适当的文档而待决 .

阅读完文档后,我有点困惑,我是否应该以我的大应用程序为基础(一个CMS,一切都将存储在一个层次结构树结构中 - 不仅是内容,还有文件等,所以你可以看到这快速扩展)在ltree,普通物化路径(Path Enumeration)周围用分隔字符串或整数数组作为路径 - 或者理论上相对未知的"树"模块应该是更快,更可扩展和更好的解决方案.

我已经分析了不同的树结构模型,由于查询性能,节点和子树的可伸缩性和重新排序是我的主要要求,我已经能够排除邻接列表(递归CTE不会解决性能,因为树缩放巨大),嵌套集/间隔(在一些查询中不够快,考虑到它在填充树时的缺点),闭包表(在复杂的树中非常大的缩放 - 对我这样的大型项目没有用)等等并决定采用物化路径,对于读取操作来说非常快,并且可以轻松地在子层次上移动子树和节点.所以问题只是关于物化路径的最佳建议实现.

我对在PostgreSQL中听到你对"树"的理论或经验感到特别好奇.

考虑以下结构:

type MyStruct struct {
    Name string
    Meta map[string]interface{}
}

其中包含以下UnmarshalXML函数:

func (m *MyStruct) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    var v struct {
        XMLName xml.Name //`xml:"myStruct"`
        Name    string   `xml:"name"`
        Meta    struct {
            Inner []byte `xml:",innerxml"`
        } `xml:"meta"`
    }

    err := d.DecodeElement(&v, &start)
    if err != nil {
        return err
    }

    m.Name = v.Name
    myMap := make(map[string]interface{})

    // ... do the mxj magic here ... -

    temp := v.Meta.Inner

    prefix := "<meta>"
    postfix := "</meta>"
    str := prefix + string(temp) …

在Node.js中,我能够使用EventEmitter轻松地创建一个WordPress克隆,从而将一个钩子系统复制并构建到CMS核心中,然后插件可以连接到该核心.

我现在需要为我的CMS写入并移植到Go的相同级别的可扩展性和核心隔离.基本上我现在已经完成了核心,但是为了使它真正灵活,我必须能够插入事件(钩子)并使插件附加到这些具有附加功能的钩子.

我不关心重新编译(动态/静态链接),只要你不必修改核心来加载插件 - 永远不应该修改CMS核心.(如WP,Drupal等)

我注意到有一些相当未知的项目,试图在Go中实现与Node.js中的EventEmitter类似的事件:

https://github.com/CHH/eventemitter

https://github.com/chuckpreslar/emission

由于上面的这两个项目没有得到太多人气和关注,我觉得这种思考事件的方式现在可能是我们应该如何在Go中做到这一点？这是否意味着Go可能不适合这项任务？通过插件制作真正可扩展的应用程序？

似乎Go没有将事件构建到其核心中,并且RPC似乎不是将插件集成到核心应用程序中的有效解决方案,就像它们本地构建一样,并且好像它们是主应用程序本身的一部分.

无缝插件集成到您的核心应用程序中的最佳方式是什么,无需扩展点(在核心中),而无需在每次需要连接新插件时操作核心？

在我的应用程序中,我已经制作了很多"服务",我可以在我的视图模型中注入,以节省som冗余和时间.

现在,我希望更进一步,并制作那些表单元素(选择,文本,复选框 - 启动器的选择下拉列表)并将它们转换为自定义元素,仅在自定义元素中注入服务.

我可以在某种程度上使它工作.我在"父"视图中需要时显示自定义元素(在这种情况下选择),但是当我更改自定义选择元素的选定值时,它不会绑定到"父"视图模型,这是我的要求.

我希望能够通过其模板中的bind属性将我选择的值从自定义元素绑定到"父"视图模型上的属性.

我会在几分钟内更新一个小代码片段.

create.js(我称之为父视图模型)

import {bindable} from 'aurelia-framework';
export class Create{
    heading = 'Create';
    @bindable myCustomElementValue = 'initial value';
}

create.html(父视图)

<template>
    <require from="shared/my-custom-element"></require>
    <my-custom selectedValue.bind="myCustomElementValue"></my-custom>
    <p>The output of ${myCustomElementValue} should ideally be shown and changed here, as the select dropdown changes</p>
</template>

我-custom.js

import { inject, bindable} from 'aurelia-framework';
import MyService from 'my-service';

@inject(MyService )
export class MyCustomCustomElement {
    @bindable selectedValue;

    constructor(myService ) {
        this.myService = myService ;
    }

    selectedValueChanged(value) {
        alert(value);
        this.selectedValue = value; …

我想知道推荐的最佳实践是处理和公开新的React Context。

操纵上下文状态的最简单方法似乎是将函数附加到上下文，该函数一旦被调用就可以调度（usereducer）或setstate（useState）来更改其内部值。

export const TodosProvider: React.FC<any> = ({ children }) => {
  const [state, dispatch] = useReducer(reducer, null, init);

  return (
    <Context.Provider
      value={{
        todos: state.todos,
        fetchTodos: async id => {
          const todos = await getTodos(id);
          console.log(id);
          dispatch({ type: "SET_TODOS", payload: todos });
        }
      }}
    >
      {children}
    </Context.Provider>
  );
};

export const Todos = id => {
  const { todos, fetchTodos } = useContext(Context);
  useEffect(() => {
    if (fetchTodos) fetchTodos(id);
  }, [fetchTodos]);
  return (
    <div>
      <pre>{JSON.stringify(todos)}</pre> …

在过去的十多天里，我看了看过的所有关于OAuth2和OpenID Connect的内容，但发现很多人不同意实现，这确实使我感到困惑。

据我了解，我发现的所有文章和示例都假设您要访问例如。Google日历，个人资料信息或电子邮件（例如）用google登录，但是除了我自己的API外，我不需要访问其他任何东西-我只想使用Google，Facebook等进行登录，并获取一个可以链接到自己数据库中的用户的ID-仅此而已。

我将尝试说明我的用例并将其用作示例。

图表上的注释：身份验证服务可能内置在API网关中-在本例中我并不重要，因为这与“在哪里做”无关，而是“如何以最佳方式做”，适用于诸如我的架构之类的架构，该架构用于我自己的API /微服务，而不访问Google，Facebook等。外部API

如果您可以理解上面这张图说明的内容，请告诉我是否误解了。

您在此处看到的对该体系结构的最基本要求是：

• 用户可以使用Google，Facebook等登录。
• 相同的登录名将用于所有微服务
• OpenId用户将在数据库中拥有一个关联帐户
• 用户访问权限是在我自己的数据库中根据组，角色和权限定义的

在用户进行身份验证和登录后，我不打算使用外部API。不需要访问用户的日历，电子邮件等。因此，我只需要身份验证部分，而无需其他任何东西（成功登录的证明）。所有用户访问权限都在我自己的数据库中定义。

因此想到了一些基本问题。

• 首先，OpenID Connect是否仅是用于身份验证的正确工具（我将没有使用授权，因为除了从身份验证中获取ID外，我不需要对google / facebook API的读/写访问权限）？
• 人们通常不同意使用ID还是访问令牌访问自己的API。据我了解，ID令牌仅用于客户端（用户代理），而访问令牌则用于。正在访问Google日历，电子邮件等。。。OpenID Provider的外部API。但是由于我将仅访问自己的API，因此我是否需要访问令牌或ID令牌-正确的保护方法是您自己的API？

如果ID令牌确实仅用于客户端，则可以显示例如。当前登录的用户，无需进入数据库，我有0个用途，因为我可能会从数据库中查询用户并将其存储在redux中以供我的React前端应用程序使用。

难题：要将用户详细信息，组，角色和权限存储在JWT内还是不进行API授权？

• 通过仅将用户标识符存储在令牌中，这意味着我始终允许具有有效令牌的经过身份验证的用户在授权之前调用端点，然后首先根据db查询结果和我自己的数据库中的权限确定访问权限。
• 通过在JWT内存储有关用户的更多数据，这意味着在某些情况下，我可以在点击API之前进行授权/访问（组，角色，权限）检查-仅在用户信息，组，登录时发布的JWT中存储的角色和权限。由于某些原因，在某些情况下这是不可能的。CMS内容访问权限位于每个节点级别。但这仍然意味着更好的性能。

如您在图上看到的，我正在通过网关发送所有API请求，这将（本身或通过身份验证服务）将不透明的访问令牌转换为带有标识符的某些JWT，因此我可以在图中识别用户数据库-然后验证用户是否具有必需的组，角色和权限-不是通过外部API，而是从我自己的数据库中获取，就像您在图中看到的那样。

即使每个服务可以共享JWT，以防多个服务需要相互交叉调用，这似乎对每个请求也要进行很多工作。

始终查找用户及其在db中的权限的好处自然是，一旦用户访问级别发生变化，他就立即被拒绝/授予访问权限，并且始终保持同步。如果我将用户详细信息，组，角色和权限存储在JWT中，并将其保留在客户端本地存储中，则我认为这可能会构成安全问题，并且很难更新用户信息，组，角色和权限在那个JWT里面？

在JWT中存储用户访问级别和信息的一大优势当然是，在许多情况下，我可以阻止用户调用某些API，而不必在数据库查找后确定访问权限。

因此，整个令牌翻译意味着以性能为代价提高安全性，但是通常建议这样做并值得吗？还是在JWT内部存储用户信息和组，角色，权限足够安全？

如果是，我是否将自己数据库中的所有信息存储在ID令牌，访问令牌或第3个令牌中-将什么令牌发送到API，并根据用户的访问权限确定是否应授予用户访问给定资源的权限数据库？如果不需要与ID提供程序API进行交互，是否真的需要访问令牌？还是我将所有的组，角色，权限存储并追加到由OpenID connect发出的ID令牌（对我来说似乎并不干净）内，并调用API并使用它授权我自己的API端点，即使有人说您永远不要使用ID令牌访问API？还是我要创建一个新的JWT来存储从数据库中获取的所有信息，该信息将用于确定用户是否可以访问给定的资源/ API端点？

请不要仅链接到常规规格或常规信息，因为我已经阅读了所有内容-我只是不明白如何将所有这些信息应用于我的实际用例（上图）。尝试请尽可能具体。

再次尝试尝试简化流程：

如果你有一个 Redux 应用程序，你想迁移到新的 React Context API + hooks (useReducer)，你将如何替换 redux-saga 或 redux-thunk 来处理副作用？我们以 redux-saga 的 github 页面为例：

import { call, put, takeEvery, takeLatest } from 'redux-saga/effects'
import Api from '...'

function* fetchUser(action) {
   try {
      const user = yield call(Api.fetchUser, action.payload.userId);
      yield put({type: "USER_FETCH_SUCCEEDED", user: user});
   } catch (e) {
      yield put({type: "USER_FETCH_FAILED", message: e.message});
   }
}

function* mySaga() {
  yield takeEvery("USER_FETCH_REQUESTED", fetchUser);
}

function* mySaga() {
  yield takeLatest("USER_FETCH_REQUESTED", fetchUser);
}

export default mySaga;

在没有 Redux 的情况下执行等效操作，而是使用 React Context api …

我试图将我的应用程序从redux重写为新的context + hooks，但是不幸的是，我很难找到一种好的方法来处理一系列依赖于先前响应的同步副作用。

在我当前的redux应用程序中，我大量使用了同步/链接操作和API请求，这些请求和API请求通常是通过redux-saga或thunk处理的。因此，当返回第一个API请求的响应时，该数据将用于下一个API请求等。

我已经制作了一个自定义钩子“ useFetch”（在此示例中，它并没有做太多，因为它是简化版本，所以我还必须对其进行一些小的调整才能在codeandbox上工作-请参见下面的代码）。问题在于由于“钩子规则”，我无法在useEffect钩子内使用自定义钩子。因此，如果您有自己的钩子来获取数据，那么在执行下一个等之前如何等待第一个请求的响应？即使我最终放弃了useFetch抽象并创建了一个香草提取请求，如何避免以许多useEffects钩子hook肿而告终？是否可以更优雅地完成此操作，还是上下文+挂钩还为时过早，无法与redux saga / thunk竞争来处理副作用？

下面的示例代码非常简单。它应该尝试模拟的是：

1. 查询人员api端点以获取人员
2. 收到人员回复后，查询工作终结点（使用真实场景中的人员ID）
3. 一旦有了人员和职位，就根据人员和职位端点的响应，查询同事端点以查找特定工作的人员同事。

这是代码。为useFetch挂钩添加了延迟，以模拟现实世界中的延迟：

import React, { useEffect, useState } from "react";
import { render } from "react-dom";

import "./styles.css";

const useFetch = (url, delay = 0) => {
  const [data, setData] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      // const result = await fetch(url, {
      //  method: "GET",
      //  headers: { "Content-Type": "application/json" }
      // });
      //const response = await result.json();
      const response = …

我具有使用PostgreSQL的ltree模块构建的这种物化路径树结构。

• id1
• id1.id2
• id1.id2.id3
• id1.id2.id5
• id1.id2.id3.id4 ...等

我当然可以轻松地使用ltree从整棵树或特定路径/子路径中获取所有节点，但是当我这样做时，自然地，我得到的是很多行（等于节点中的节点的数组/切片）结束.. Golang /您使用的任何编程语言）

我要做的是将树（理想情况下是从某个起点和终点的路径/点）作为树状JSON树对象等来获取

{
  "id": 1,
  "path": "1",
  "name": "root",
  "children": [
    {
      "id": 2,
      "path": "1.2",
      "name": "Node 2",
      "children": [
        {
          "id": 3,
          "path": "1.2.3",
          "name": "Node 3",
          "children": [
            {
              "id": 4,
              "path": "1.2.3.4",
              "name": "Node 4",
              "children": [

              ]
            }
          ]
        },
        {
          "id": 5,
          "path": "1.2.5",
          "name": "Node 5",
          "children": [

          ]
        }
      ]
    }
  ]
}

我从线性（非分层）行/数组/切片结果集中知道，我当然可以在Golang中进行分解，并在其中进行创建此json的必要业务逻辑，但是如果有方便的话，肯定会好得多直接通过PostgreSQL实现此目标的方法。

那么，您如何在PostgreSQL中将ltree树形结构输出到json-从起始路径到结束路径都集中地？

如果您不知道ltree，我想这个问题可能会进一步推广到“分层路径树到分层json”

我也在考虑在ltree路径之外的所有节点上添加一个parent_id的想法，因为至少那样我就可以使用使用该id的递归调用来获取我猜的json ...我也考虑过根据父ID的更改发生时间在该parent_id上放置触发器以管理路径（保持更新）-我知道这是另一个问题，但是也许您也可以告诉我您的观点，对此吗？

我希望有一些天才可以帮助我。:)

为了方便起见，这里有一个示例创建脚本，可用于节省时间：

CREATE TABLE node …